Publications

You can also check my ORCID, Google Scholar, Semantic Scholar, and dblp profiles.

Preprints

Journal articles

Stateful Serverless Computing with Crucial (2022)
Daniel Barcelona-Pons, Pierre Sutra, Marc Sánchez-Artigas, Gerard París, and Pedro García-López. ACM Trans. Softw. Eng. Methodol. 31, 3 (Mar. 2022).
```
@article{barcelonapons2022crucial,
  author = {Barcelona-Pons, Daniel and Sutra, Pierre and S\'{a}nchez-Artigas, Marc and Par\'{i}s, Gerard and Garc\'{i}a-L\'{o}pez, Pedro},
  title = {Stateful Serverless Computing with Crucial},
  year = {2022},
  issue_date = {July 2022},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  volume = {31},
  number = {3},
  issn = {1049-331X},
  url = {https://doi.org/10.1145/3490386},
  doi = {10.1145/3490386},
  journal = {ACM Trans. Softw. Eng. Methodol.},
  month = mar,
  articleno = {39},
  numpages = {38},
  keywords = {Serverless, synchronization, stateful, in-memory, FaaS}
}
```
Serverless computing greatly simplifies the use of cloud resources. In particular, Function-as-a-Service (FaaS) platforms enable programmers to develop applications as individual functions that can run and scale independently. Unfortunately, applications that require fine-grained support for mutable state and synchronization, such as machine learning (ML) and scientific computing, are notoriously hard to build with this new paradigm. In this work, we aim at bridging this gap. We present Crucial, a system to program highly-parallel stateful serverless applications. Crucial retains the simplicity of serverless computing. It is built upon the key insight that FaaS resembles to concurrent programming at the scale of a datacenter. Accordingly, a distributed shared memory layer is the natural answer to the needs for fine-grained state management and synchronization. Crucial allows to port effortlessly a multi-threaded code base to serverless, where it can benefit from the scalability and pay-per-use model of FaaS platforms. We validate Crucial with the help of micro-benchmarks and by considering various stateful applications. Beyond classical parallel tasks (e.g., a Monte Carlo simulation), these applications include representative ML algorithms such as k-means and logistic regression. Our evaluation shows that Crucial obtains superior or comparable performance to Apache Spark at similar cost (18%–40% faster). We also use Crucial to port (part of) a state-of-the-art multi-threaded ML library to serverless. The ported application is up to 30% faster than with a dedicated high-end server. Finally, we attest that Crucial can rival in performance with a single-machine, multi-threaded implementation of a complex coordination problem. Overall, Crucial delivers all these benefits with less than 6% of changes in the code bases of the evaluated applications.
Benchmarking Parallelism in FaaS Platforms (2021)
Daniel Barcelona-Pons and Pedro García-López. Future Gener. Comput. Syst. 124, C (Nov. 2021).
```
@article{barcelonapons2021faasbench,
  author = {Barcelona-Pons, Daniel and Garc\'{i}a-L\'{o}pez, Pedro},
  title = {Benchmarking Parallelism in FaaS Platforms},
  year = {2021},
  issue_date = {Nov 2021},
  publisher = {Elsevier Science Publishers B. V.},
  address = {NLD},
  volume = {124},
  number = {C},
  issn = {0167-739X},
  url = {https://doi.org/10.1016/j.future.2021.06.005},
  doi = {10.1016/j.future.2021.06.005},
  journal = {Future Gener. Comput. Syst.},
  month = nov,
  pages = {268–284},
  numpages = {17},
  keywords = {FaaS, Parallelism, Benchmark, Serverless}
}
```
Serverless computing has seen a myriad of work exploring its potential. Some systems tackle Function-as-a-Service (FaaS) properties on automatic elasticity and scale to run highly-parallel computing jobs. However, they focus on specific platforms and convey that their ideas can be extrapolated to any FaaS runtime.An important question arises: do all FaaS platforms fit parallel computations? In this paper, we argue that not all of them provide the necessary means to host highly-parallel applications. To validate our hypothesis, we create a comparative framework and categorize the architectures of four cloud FaaS offerings, emphasizing parallel performance. We attest and extend this description with an empirical experiment that consists in plotting in deep detail the evolution of a parallel computing job on each service.The analysis of our results evinces that FaaS is not inherently good for parallel computations and architectural differences across platforms are decisive to categorize their performance. A key insight is the importance of virtualization technologies and the scheduling approach of FaaS platforms. Parallelism improves with lighter virtualization and proactive scheduling due to finer resource allocation and faster elasticity. This causes some platforms like AWS and IBM to perform well for highly-parallel computations, while others such as Azure present difficulties to achieve the required parallelism degree. Consequently, the information in this paper becomes of special interest to help users choose the most adequate infrastructure for their parallel applications.

Conference proceedings

Dataplug: Unlocking extreme data analytics with on-the-fly dynamic partitioning of unstructured data (2024)
Aitor Arjona, Pedro Garcia-Lopez, and Daniel Barcelona-Pons. 2024 IEEE 24th International Symposium on Cluster, Cloud and Internet Computing (CCGrid) .
```
@inproceedings{arjona2024dataplug,
  author = {Arjona, Aitor and Garcia-Lopez, Pedro and Barcelona-Pons, Daniel},
  booktitle = { 2024 IEEE 24th International Symposium on Cluster, Cloud and Internet Computing (CCGrid) },
  title = {{ Dataplug: Unlocking extreme data analytics with on-the-fly dynamic partitioning of unstructured data }},
  year = {2024},
  volume = {},
  issn = {},
  pages = {567-576},
  keywords = {Cloud computing;Costs;Scientific computing;Semantics;Genomics;Distributed databases;Bandwidth;Dynamic scheduling;Geospatial analysis;Bioinformatics;data partitioning;Cloud;object storage;scientific data management;unstructured data;data analytics},
  doi = {10.1109/CCGrid59990.2024.00069},
  url = {https://doi.org/10.1109/CCGrid59990.2024.00069},
  publisher = {IEEE Computer Society},
  address = {Los Alamitos, CA, USA},
  month = may
}
```
The elasticity of the Cloud is very appealing for processing large scientific data. However, enormous volumes of unstructured research data, totaling petabytes, remain untapped in data repositories due to the lack of efficient parallel data access. Even-sized partitioning of these data to enable its parallel processing requires a complete re-write to storage, becoming prohibitively expensive for high volumes. In this article we present Dataplug, an extensible framework that enables fine-grained parallel data access to unstructured scientific data in object storage. Dataplug employs read-only, format-aware indexing, allowing to define dynamically-sized partitions using various partitioning strategies. This approach avoids writing the partitioned dataset back to storage, enabling distributed workers to fetch data partitions on-the-fly directly from large data blobs, efficiently leveraging the high bandwidth capability of object storage. Validations on genomic (FASTQGZip) and geospatial (LiDAR) data formats demonstrate that Dataplug considerably lowers pre-processing compute costs (between 65.5% — 71.31% less) without imposing significant overheads.
Serverful Functions: Leveraging Servers in Complex Serverless Workflows (industry track) (2024)
Germán T. Eizaguirre, Daniel Barcelona-Pons, Aitor Arjona, Gil Vernik, Garcı́a-López Pedro, and Theodore Alexandrov. Proceedings of the 25th International Middleware Conference Industrial Track (Middleware Industrial Track ’24).
```
@inproceedings{eizaguirre2024serverful,
  author = {Eizaguirre, Germ\'{a}n T. and Barcelona-Pons, Daniel and Arjona, Aitor and Vernik, Gil and Garc\'{\i}a-L\'{o}pez, Pedro and Alexandrov, Theodore},
  title = {Serverful Functions: Leveraging Servers in Complex Serverless Workflows (industry track)},
  year = {2024},
  isbn = {9798400713194},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3700824.3701095},
  doi = {10.1145/3700824.3701095},
  booktitle = {Proceedings of the 25th International Middleware Conference Industrial Track},
  pages = {15–21},
  numpages = {7},
  keywords = {Cloud computing, function-as-a-service, resource allocation, resource efficiency, serverless computing},
  location = {Hong Kong, Hong Kong},
  series = {Middleware Industrial Track '24}
}
```
The scalability of cloud functions makes them a convenient backend for elastic data analytics pipelines where parallelism changes drastically from one stage to the next. However, cloud functions require intermediate storage systems for communication, which limits the efficiency of stateful operations. Furthermore, cloud functions are expensive, which reduces the cost-effectiveness of pure serverless architectures. We propose a hybrid architecture for data analytics that uses cloud functions for embarrassingly parallel stages and virtual cloud instances for stateful operations under a unified serverless programming framework. Extending Lithops, a serverless programming library, we implement a parallel programming interface that proactively provisions serverless and serverful cloud resources with minimal user intervention. We validate the feasibility of a hybrid architecture, by comparing it to fully serverless and serverful versions of a production-level metabolomics pipeline. We show that mixing cloud functions with virtual instances increases the cost-effectiveness of the execution by up to 188.23% over the serverless implementation, while achieving a speedup of 3.64 compared to the serverful one.
Glider: Serverless Ephemeral Stateful Near-Data Computation (2023)
Daniel Barcelona-Pons, Pedro García-López, and Bernard Metzler. Proceedings of the 24th International Middleware Conference (Middleware ’23).
```
@inproceedings{barcelonapons2023glider,
  author = {Barcelona-Pons, Daniel and Garc\'{i}a-L\'{o}pez, Pedro and Metzler, Bernard},
  title = {Glider: Serverless Ephemeral Stateful Near-Data Computation},
  year = {2023},
  isbn = {9798400701771},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3590140.3629119},
  doi = {10.1145/3590140.3629119},
  booktitle = {Proceedings of the 24th International Middleware Conference},
  pages = {247–260},
  numpages = {14},
  keywords = {Serverless, stateful, cloud, near-data, ephemeral, intermediate data},
  location = {Bologna, Italy},
  series = {Middleware '23}
}
```
Serverless data analytics generate a large amount of intermediate data during computation stages. However, serverless functions, which are short-lived and lack direct communication, face significant challenges in managing this data effectively. The traditional approach of using object storage to carry the data proves to be slow and costly, as it involves constant movement of data back and forth. Although specialized ephemeral storage solutions have been developed to address this issue, they fail to tackle the fundamental challenge of minimizing data movements. This work focuses on incorporating near-data computation into an ephemeral storage system to reduce the volume of transferred data in serverless analytics. We present Glider with the aim to enhance communication between serverless compute stages, allowing data to smoothly "glide" through the processing pipeline instead of bouncing between different services. Glider achieves this by leveraging stateful near-data execution of complex data-bound operations and an efficient I/O streaming interface. Under evaluation, it reduces data transfers by up to 99.7%, improves storage utilization by up to 99.8%, and enhances performance by up to 2.7×. In sum, Glider improves serverless data analytics by optimizing data movement, streamlining processing, and avoiding redundant transfers.
On the FaaS Track: Building Stateful Distributed Applications with Serverless Architectures (2019)
Daniel Barcelona-Pons, Marc Sánchez-Artigas, Gerard París, Pierre Sutra, and Pedro García-López. Proceedings of the 20th International Middleware Conference (Middleware ’19).
```
@inproceedings{barcelonapons2019crucial,
  author = {Barcelona-Pons, Daniel and S\'{a}nchez-Artigas, Marc and Par\'{i}s, Gerard and Sutra, Pierre and Garc\'{i}a-L\'{o}pez, Pedro},
  title = {On the FaaS Track: Building Stateful Distributed Applications with Serverless Architectures},
  year = {2019},
  isbn = {9781450370097},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3361525.3361535},
  doi = {10.1145/3361525.3361535},
  booktitle = {Proceedings of the 20th International Middleware Conference},
  pages = {41–54},
  numpages = {14},
  keywords = {in-memory, FaaS, stateful, synchronization, Serverless},
  location = {Davis, CA, USA},
  series = {Middleware '19}
}
```
Serverless computing is an emerging paradigm that greatly simplifies the usage of cloud resources and suits well to many tasks. Most notably, Function-as-a-Service (FaaS) enables programmers to develop cloud applications as individual functions that can run and scale independently. Yet, due to the disaggregation of storage and compute resources in FaaS, applications that require fine-grained support for mutable state and synchronization, such as machine learning and scientific computing, are hard to build.In this work, we present Crucial, a system to program highly-concurrent stateful applications with serverless architectures. Its programming model keeps the simplicity of FaaS and allows to port effortlessly multi-threaded algorithms to this new environment. Crucial is built upon the key insight that FaaS resembles to concurrent programming at the scale of a data center. As a consequence, a distributed shared memory layer is the right answer to the need for fine-grained state management and coordination in serverless. We validate our system with the help of micro-benchmarks and various applications. In particular, we implement two common machine learning algorithms: k-means clustering and logistic regression. For both cases, Crucial obtains superior or comparable performance to an equivalent Spark cluster.
FaaS Orchestration of Parallel Workloads (2019)
Daniel Barcelona-Pons, Pedro García-López, Álvaro Ruiz, Amanda Gómez-Gómez, Gerard París, and Marc Sánchez-Artigas. Proceedings of the 5th International Workshop on Serverless Computing (WOSC ’19).
```
@inproceedings{barcelonapons2019faasorch,
  author = {Barcelona-Pons, Daniel and Garc\'{i}a-L\'{o}pez, Pedro and Ruiz, \'{A}lvaro and G\'{o}mez-G\'{o}mez, Amanda and Par\'{i}s, Gerard and S\'{a}nchez-Artigas, Marc},
  title = {FaaS Orchestration of Parallel Workloads},
  year = {2019},
  isbn = {9781450370387},
  publisher = {Association for Computing Machinery},
  address = {New York, NY, USA},
  url = {https://doi.org/10.1145/3366623.3368137},
  doi = {10.1145/3366623.3368137},
  booktitle = {Proceedings of the 5th International Workshop on Serverless Computing},
  pages = {25–30},
  numpages = {6},
  keywords = {Serverless, FaaS, orchestration, event-based},
  location = {Davis, CA, USA},
  series = {WOSC '19}
}
```
Function as a Service (FaaS) is based on a reactive programming model where functions are activated by triggers in response to cloud events (e.g., objects added to an object store). The inherent elasticity and the pay-per-use model of serverless functions make them very appropriate for embarrassingly parallel tasks like data preprocessing, or even the execution of MapReduce jobs in the cloud.But current Serverless orchestration systems are not designed for managing parallel fork-join workflows in a scalable and efficient way. We demonstrate in this paper that existing services like AWS Step Functions or Azure Durable Functions incur in considerable overheads, and only Composer at IBM Cloud provides suitable performance.Successively, we analyze the architecture of OpenWhisk as an open-source FaaS systems and its orchestration features (Composer). We outline its architecture problems and propose guidelines for orchestrating massively parallel workloads using serverless functions.
Comparison of FaaS Orchestration Systems (2018)
Pedro García López, Marc Sánchez-Artigas, Gerard París, Daniel Barcelona-Pons, Álvaro Ruiz Ollobarren, and David Arroyo Pinto. 2018 IEEE/ACM International Conference on Utility and Cloud Computing Companion (UCC Companion) (WOSC ’18).
```
@inproceedings{garcialopez2018comparefaas,
  author = {García López, Pedro and Sánchez-Artigas, Marc and París, Gerard and Barcelona-Pons, Daniel and Ruiz Ollobarren, Álvaro and Arroyo Pinto, David},
  booktitle = {2018 IEEE/ACM International Conference on Utility and Cloud Computing Companion (UCC Companion)},
  title = {Comparison of FaaS Orchestration Systems},
  year = {2018},
  publisher = {IEEE},
  pages = {148-153},
  doi = {10.1109/UCC-Companion.2018.00049},
  series = {WOSC '18}
}
```
Since the appearance of Amazon Lambda in 2014, all major cloud providers have embraced the "Function as a Service" (FaaS) model, because of its enormous potential for a wide variety of applications. As expected (and also desired), the competition is fierce in the serverless world, and includes aspects such as the run-time support for the orchestration of serverless functions. In this regard, the three major production services are currently Amazon Step Functions (December 2016), Azure Durable Functions (June 2017), and IBM Composer (October 2017), still young and experimental projects with a long way ahead. In this article, we will compare and analyze these three serverless orchestration systems under a common evaluation framework. We will study their architectures, programming and billing models, and their effective support for parallel execution, among others. Through a series of experiments, we will also evaluate the run-time overhead of the different infrastructures for different types of workflows.

Theses

Towards Enhanced State Management for Serverless Computation (2022)
Daniel Barcelona-Pons. Doctoral Thesis. Universitat Rovira i Virgili.
```
@phdthesis{barcelonapons2022thesis,
  author = {Barcelona-Pons, Daniel},
  school = {Universitat Rovira i Virgili},
  note = {Doctoral Thesis},
  title = {Towards Enhanced State Management for Serverless Computation},
  year = {2022},
  url = {http://hdl.handle.net/10803/687462}
}
```
Cloud computing is becoming more accessible and fitting for many applications. In this line, and with fervent interest from research and industry, there is the concept of serverless. Serverless services hide the existence of servers from users, so that they can focus on their applications. In the trend to exploit the elasticity of serverless computing, distributed parallel computations such as analytics, machine learning, and data processing have special attention from researchers. However, current serverless services are unfitted out-of-the-box to support parallel applications. Broadly, the issues come from a lack of state management, coordination, and predictability. This context opens several research lines; we discuss three: 1) It is unclear how well can current serverless services support distributed parallel computing, which requires execution simultaneity and performance consistency. Current platforms do not ensure that, and users may find extreme variability between services. 2) Current serverless computing exclusively offers stateless ephemeral workers with no direct communication. Applications built on top of these services struggle to manage their mutable global state and coordinate their execution. 3) Intermediate data generated during data processing workloads is forcibly transferred between workers and disaggregated storage. This data-shipping model generates very expensive data movement. In this thesis, we present tree novel contributions to tackle these challenges. First, we study the architectural design of the main serverless platforms and empirically evaluate them to find the platforms that best fit parallel applications. Second, we explore novel methods to code stateful distributed applications in serverless. We present the cloud thread abstraction and build a shared objects layer that allows serverless workers to share and mutate global state and coordinate their execution. Finally, we study a solution to serverless data-shipping through in-storage ephemeral stateful computation. We build a storage system that allows to offload data-bound tasks from serverless workers and significantly reduce data movement.