Demand-driven incremental object queries

Liu, Yanhong A.; Brandvein, Jon; Stoller, Scott D.; Lin, Bo

doi:10.1145/2967973.2968610

Cited by 10 publications

(5 citation statements)

References 54 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…To run a task mutually exclusively, the process sends a request and adds it to q (lines 6-8), waits for (i) own request (t,self) to be before each other request (t2,p2) in q and (ii) having received an ack with a time t2 later than t from each process p2 in s (lines 9-10) before doing the task in critical section (line 11), and then removes the request from q and sends a release (lines 12-13). When receiving a request or release, it sends back an ack and adds to or removes from q (lines [14][15][16][17][18][19]. The two conditions in await are key to the algorithm to ensure mutual exclusion, while the rest does basic sending and receiving of messages and bookkeeping of q.…”

Section: Creating Variants Using Incrementalizationmentioning

confidence: 99%

“…A more general automated approach is to generate them by starting with a high-level algorithm (or specification) and applying different optimizations (algorithm improvements, automated using program analysis and transformation). In particular, we have used a method based on systematic incrementalization [27,22,19,18], which transforms programs to maintain high-level invariants incrementally, and related optimizations to generate multiple variants of many sequential algorithms and distributed algorithms [26,25,24]. Algorithm diversity and implementation-level diversity introduce different kinds of variation and together offer more diversity than either alone.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Algorithm Diversity for Resilient Systems

Stoller

Liu

2019

Data and Applications Security and Privacy XXXIII

Self Cite

View full text Add to dashboard Cite

Diversity can significantly increase the resilience of systems, by reducing the prevalence of shared vulnerabilities and making vulnerabilities harder to exploit. Work on software diversity for security typically creates variants of a program using low-level code transformations. This paper is the first to study algorithm diversity for resilience. We first describe how a method based on high-level invariants and systematic incrementalization can be used to create algorithm variants. Executing multiple variants in parallel and comparing their outputs provides greater resilience than executing one variant. To prevent different parallel schedules from causing variants' behaviors to diverge, we present a synchronized execution algorithm for DistAlgo, an extension of Python for high-level, precise, executable specifications of distributed algorithms. We propose static and dynamic metrics for measuring diversity. An experimental evaluation of algorithm diversity combined with implementation-level diversity for several sequential algorithms and distributed algorithms shows the benefits of algorithm diversity.

show abstract

Section: Creating Variants Using Incrementalizationmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Algorithm Diversity for Resilient Systems

Stoller

Liu

2019

Data and Applications Security and Privacy XXXIII

Self Cite

View full text Add to dashboard Cite

show abstract

“…IncOQ [30] improves over OSQ by tracking dependencies statically and incorporating demand. However, the same limitations apply: only set comprehensions and only in-memory.…”

Section: Icls For Information Systemsmentioning

confidence: 99%

Migrating business logic to an incremental computing DSL: a case study

Harkes

Chastelet

Visser

2018

Proceedings of the 11th ACM SIGPLAN International Conference on Software Language Engineering

View full text Add to dashboard Cite

To provide empirical evidence to what extent migration of business logic to an incremental computing language (ICL) is useful, we report on a case study on a learning management system. Our contribution is to analyze a real-life project, how migrating business logic to an ICL affects information system validatability, performance, and development effort.We find that the migrated code has better validatability; it is straightforward to establish that a program 'does the right thing'. Moreover, the performance is better than the previous hand-written incremental computing solution. The effort spent on modeling business logic is reduced, but integrating that logic in the application and tuning performance takes considerable effort. Thus, the ICL separates the concerns of business logic and performance, but does not reduce effort.CCS Concepts • Information systems → Web applications; Enterprise information systems; • Software and its engineering → Domain specific languages;

show abstract

“…ICQ [59] handles queries in object-oriented languages like Java by converting the problem to relational logic and statically constructing a graph of relationships between collections. While capable of incrementalizing queries containing arbitrary filter predicates, it does not know the semantics of those predicates.…”

Section: Incremental Computationmentioning

confidence: 99%

Data structure synthesis

Loncaric

2016

Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering

View full text Add to dashboard Cite

School of Computer Science and EngineeringData structures are integral to software. Many programs require custom application-specific data structures more complicated than those found in standard libraries. Implementing and maintaining application-specific data structures is tedious and error-prone. This work presents Cozy, a novel tool that synthesizes efficient implementations of applicationspecific data structures from high-level specifications. Cozy handles a wider range of data structures than previous work, including structures that track multiple related collections and have complex retrieval methods involving sums, counts, minimums, and maximums.Cozy iteratively discovers good data structures using alternating steps of query synthesis and state maintenance. The query synthesis step implements pure operations over the data structure state by leveraging existing enumerative synthesis techniques, specialized to the data structures domain. The state maintenance step implements imperative state modifications by re-framing them as fresh queries that determine what to change, coupled with a small amount of code to apply the change. As an added benefit of this approach over previous work, the synthesized data structure is optimized for not only the queries in the specification but also the required update operations.Cozy has three goals: to reduce programmer effort, to produce bug-free code, and to match the performance of handwritten code. We have evaluated Cozy in four large case studies, demonstrating that it meets the goals. Using Cozy requires an order of magnitude fewer lines of code than manual implementation, results in fewer bugs, and matches the performance of handwritten code.Finally, we have used Cozy as an automatic incrementalizer. An incremental algorithm can update its output efficiently in response to small changes to its input. Replacing batch-style algorithms with incremental versions yields incredible speedups when the input data changes frequently. Cozy is well-suited to the problem since incrementalization is simply the task of finding the right data structure to track state between changes to the input. By re-framing the incremental computation task as a data structure specification we can produce efficient incremental versions in more situations than previous work.

show abstract

Demand-driven incremental object queries

Cited by 10 publications

References 54 publications

Algorithm Diversity for Resilient Systems

Algorithm Diversity for Resilient Systems

Migrating business logic to an incremental computing DSL: a case study

Data structure synthesis

Contact Info

Product

Resources

About