SD
S.A. Dimakos
info
Please Note
<p>This page displays the records of the person named above and is not linked to a unique person identifier. This record may need to be merged to a profile.</p>
2 records found
1
Serverless computing has transformed how distributed applications are built, enabling developers to deploy event-driven, scalable services without managing infrastructure. Early work on extending this paradigm to stateful applications through Stateful Function-as-a-Service (SFaaS) has shown that co-locating state with compute, effectively eliminating the "shipping data to code" problem, yields significant gains in throughput and latency. Systems such as Styx demonstrate that SFaaS can deliver serializable, exactly-once transactional guarantees across arbitrary function call-graphs at high performance. However, these performance benefits come at a cost: developers must decompose naturally sequential workflows into chains of asynchronous callbacks, manually managing continuations, context serialization, and distributed control flow, pulling attention away from business logic and toward distributed coordination.
In this thesis, we present Obol, a compiler-driven approach that raises the level of abstraction for SFaaS programming. Obol allows developers to express distributed stateful workflows as ordinary sequential, object-oriented code, and automatically compiles it to the asynchronous message-passing form required by the underlying runtime. We show that a multi-stage compiler pipeline can translate standard object-oriented constructs into correct distributed dataflow programs without sacrificing the transactional guarantees of the target runtime. We evaluate Obol on the YCSB and TPC-C benchmarks and demonstrate that the compiled code tracks hand-written operator latency to within a few percent up to saturation and saturates only modestly earlier. The residual gap is not compilation overhead, which a control workload isolates at essentially zero, but the cost of Obol's structured reply routing relative to hand-tuned callback wiring, a cost that the available concurrency constructs and optimizations significantly decrease. ...
In this thesis, we present Obol, a compiler-driven approach that raises the level of abstraction for SFaaS programming. Obol allows developers to express distributed stateful workflows as ordinary sequential, object-oriented code, and automatically compiles it to the asynchronous message-passing form required by the underlying runtime. We show that a multi-stage compiler pipeline can translate standard object-oriented constructs into correct distributed dataflow programs without sacrificing the transactional guarantees of the target runtime. We evaluate Obol on the YCSB and TPC-C benchmarks and demonstrate that the compiled code tracks hand-written operator latency to within a few percent up to saturation and saturates only modestly earlier. The residual gap is not compilation overhead, which a control workload isolates at essentially zero, but the cost of Obol's structured reply routing relative to hand-tuned callback wiring, a cost that the available concurrency constructs and optimizations significantly decrease. ...
Serverless computing has transformed how distributed applications are built, enabling developers to deploy event-driven, scalable services without managing infrastructure. Early work on extending this paradigm to stateful applications through Stateful Function-as-a-Service (SFaaS) has shown that co-locating state with compute, effectively eliminating the "shipping data to code" problem, yields significant gains in throughput and latency. Systems such as Styx demonstrate that SFaaS can deliver serializable, exactly-once transactional guarantees across arbitrary function call-graphs at high performance. However, these performance benefits come at a cost: developers must decompose naturally sequential workflows into chains of asynchronous callbacks, manually managing continuations, context serialization, and distributed control flow, pulling attention away from business logic and toward distributed coordination.
In this thesis, we present Obol, a compiler-driven approach that raises the level of abstraction for SFaaS programming. Obol allows developers to express distributed stateful workflows as ordinary sequential, object-oriented code, and automatically compiles it to the asynchronous message-passing form required by the underlying runtime. We show that a multi-stage compiler pipeline can translate standard object-oriented constructs into correct distributed dataflow programs without sacrificing the transactional guarantees of the target runtime. We evaluate Obol on the YCSB and TPC-C benchmarks and demonstrate that the compiled code tracks hand-written operator latency to within a few percent up to saturation and saturates only modestly earlier. The residual gap is not compilation overhead, which a control workload isolates at essentially zero, but the cost of Obol's structured reply routing relative to hand-tuned callback wiring, a cost that the available concurrency constructs and optimizations significantly decrease.
In this thesis, we present Obol, a compiler-driven approach that raises the level of abstraction for SFaaS programming. Obol allows developers to express distributed stateful workflows as ordinary sequential, object-oriented code, and automatically compiles it to the asynchronous message-passing form required by the underlying runtime. We show that a multi-stage compiler pipeline can translate standard object-oriented constructs into correct distributed dataflow programs without sacrificing the transactional guarantees of the target runtime. We evaluate Obol on the YCSB and TPC-C benchmarks and demonstrate that the compiled code tracks hand-written operator latency to within a few percent up to saturation and saturates only modestly earlier. The residual gap is not compilation overhead, which a control workload isolates at essentially zero, but the cost of Obol's structured reply routing relative to hand-tuned callback wiring, a cost that the available concurrency constructs and optimizations significantly decrease.
Addressing the challenge of reasoning about programs across different evaluation strategies has long been a concern in functional programming. Levy's introduction of the call-by-push-value (CBPV) calculus represents a significant step forward in tackling this. His paradigm provided a more powerful approach that can encapsulate both call-by-value and call-by-name that was even later extended to include call-by-need. In this paper we present the development of an interface that integrates the theory of CBPV with algebraic effects and handlers. We demonstrate how this technique enables the definition and execution of programs, highlighting its capability to defer computations across different evaluation strategies and define operations in a modular fashion. We then define and prove a set of laws that can be used with our interface to reason about programs under varying evaluation regimes. This approach not only enhances the flexibility and modularity of language and library implementation but also allows for direct reasoning about these implementations, beyond the meta-level abstraction.
...
Addressing the challenge of reasoning about programs across different evaluation strategies has long been a concern in functional programming. Levy's introduction of the call-by-push-value (CBPV) calculus represents a significant step forward in tackling this. His paradigm provided a more powerful approach that can encapsulate both call-by-value and call-by-name that was even later extended to include call-by-need. In this paper we present the development of an interface that integrates the theory of CBPV with algebraic effects and handlers. We demonstrate how this technique enables the definition and execution of programs, highlighting its capability to defer computations across different evaluation strategies and define operations in a modular fashion. We then define and prove a set of laws that can be used with our interface to reason about programs under varying evaluation regimes. This approach not only enhances the flexibility and modularity of language and library implementation but also allows for direct reasoning about these implementations, beyond the meta-level abstraction.