@inproceedings{LEONARCZYK:ERAD:23,
title = {Avaliação da Auto-Adaptação de Micro-Lote para aplicação de Processamento de Streaming em GPUs},
author = {Ricardo Leonarczyk and Dalvan Griebler},
url = {https://doi.org/10.5753/eradrs.2023.229267},
doi = {10.5753/eradrs.2023.229267},
year = {2023},
date = {2023-05-01},
booktitle = {Anais da XXIII Escola Regional de Alto Desempenho da Região Sul},
pages = {123-124},
publisher = {Sociedade Brasileira de Computação},
address = {Porto Alegre, Brazil},
abstract = {Este artigo apresenta uma avaliação de algoritmos para regular a latência através da auto-adaptação de micro-lote em sistemas de processamento de streaming acelerados por GPU. Os resultados demonstraram que o algoritmo com o fator de adaptação fixo conseguiu ficar por mais tempo na região de latência especificada para a aplicação.},
keywords = {GPGPU, Self-adaptation, Stream processing},
pubstate = {published},
tppubtype = {inproceedings}
}

@inproceedings{VOGEL:PDP:23,
title = {Revisiting self-adaptation for efficient decision-making at run-time in parallel executions},
author = {Adriano Vogel and Marco Danelutto and Dalvan Griebler and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1109/PDP59025.2023.00015},
doi = {10.1109/PDP59025.2023.00015},
year = {2023},
date = {2023-03-01},
booktitle = {31st Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)},
pages = {43-50},
publisher = {IEEE},
address = {Naples, Italy},
series = {PDP'23},
abstract = {Self-adaptation is a potential alternative to provide a higher level of autonomic abstractions and run-time responsiveness in parallel executions. However, the recurrent problem is that self-adaptation is still limited in flexibility and efficiency. For instance, there is a lack of mechanisms to apply adaptation actions and efficient decision-making strategies to decide which configurations should be conveniently enforced at run-time. In this work, we are interested in providing and evaluating potential abstractions achievable with self-adaptation transparently managing parallel executions. Therefore, we provide a new mechanism to support self-adaptation in applications with multiple parallel stages executed in multi-cores. Moreover, we reproduce, reimplement, and evaluate an existing decision-making strategy in our scenario. The observations from the results show that the proposed mechanism for self-adaptation can provide new parallelism abstractions and autonomous responsiveness at run-time. On the other hand, there is a need for more accurate decision-making strategies to enable efficient executions of applications in resource-constrained scenarios like multi-cores.},
keywords = {Parallel programming, Self-adaptation},
pubstate = {published},
tppubtype = {inproceedings}
}

@article{GARCIA:JS:23,
title = {Micro-batch and data frequency for stream processing on multi-cores},
author = {Adriano Marques Garcia and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1007/s11227-022-05024-y},
doi = {10.1007/s11227-022-05024-y},
year = {2023},
date = {2023-01-01},
journal = {The Journal of Supercomputing},
volume = {79},
number = {8},
pages = {9206-9244},
publisher = {Springer},
abstract = {Latency or throughput is often critical performance metrics in stream processing. Applications’ performance can fluctuate depending on the input stream. This unpredictability is due to the variety in data arrival frequency and size, complexity, and other factors. Researchers are constantly investigating new ways to mitigate the impact of these variations on performance with self-adaptive techniques involving elasticity or micro-batching. However, there is a lack of benchmarks capable of creating test scenarios to further evaluate these techniques. This work extends and improves the SPBench benchmarking framework to support dynamic micro-batching and data stream frequency management. We also propose a set of algorithms that generates the most commonly used frequency patterns for benchmarking stream processing in related work. It allows the creation of a wide variety of test scenarios. To validate our solution, we use SPBench to create custom benchmarks and evaluate the impact of micro-batching and data stream frequency on the performance of Intel TBB and FastFlow. These are two libraries that leverage stream parallelism for multi-core architectures. Our results demonstrated that our test cases did not benefit from micro-batches on multi-cores. For different data stream frequency configurations, TBB ensured the lowest latency, while FastFlow assured higher throughput in shorter pipelines.},
keywords = {Benchmark, Self-adaptation, Stream processing},
pubstate = {published},
tppubtype = {article}
}

@article{VOGEL:Computing:23,
title = {Online and Transparent Self-adaptation of Stream Parallel Patterns},
author = {Adriano Vogel and Gabriele and Mencagli and Dalvan Griebler and Marco Danelutto and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1007/s00607-021-00998-8},
doi = {10.1007/s00607-021-00998-8},
year = {2021},
date = {2021-05-01},
journal = {Computing},
volume = {105},
number = {5},
pages = {1039-1057},
publisher = {Springer},
abstract = {Several real-world parallel applications are becoming more dynamic and long-running, demanding online (at run-time) adaptations. Stream processing is a representative scenario that computes data items arriving in real-time and where parallel executions are necessary. However, it is challenging for humans to monitor and manually self-optimize complex and long-running parallel executions continuously. Moreover, although high-level and structured parallel programming aims to facilitate parallelism, several issues still need to be addressed for improving the existing abstractions. In this paper, we extend self-adaptiveness for supporting autonomous and online changes of the parallel pattern compositions. Online self-adaptation is achieved with an online profiler that characterizes the applications, which is combined with a new self-adaptive strategy and a model for smooth transitions on reconfigurations. The solution provides a new abstraction layer that enables application programmers to define non-functional requirements instead of hand-tuning complex configurations. Hence, we contribute with additional abstractions and flexible self-adaptation for responsiveness at run-time. The proposed solution is evaluated with applications having different processing characteristics, workloads, and configurations. The results show that it is possible to provide additional abstractions, flexibility, and responsiveness while achieving performance comparable to the best static configuration executions.},
keywords = {Parallel programming, Self-adaptation, Stream processing},
pubstate = {published},
tppubtype = {article}
}

@inproceedings{VOGEL:PDP:21,
title = {Towards On-the-fly Self-Adaptation of Stream Parallel Patterns},
author = {Adriano Vogel and Gabriele Mencagli and Dalvan Griebler and Marco Danelutto and Luiz Gustavo Fernandes},
doi = {10.1109/PDP52278.2021.00022},
year = {2021},
date = {2021-03-01},
booktitle = {29th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)},
pages = {89-93},
publisher = {IEEE},
address = {Valladolid, Spain},
series = {PDP'21},
abstract = {Stream processing applications compute streams of data and provide insightful results in a timely manner, where parallel computing is necessary for accelerating the application executions. Considering that these applications are becoming increasingly dynamic and long-running, a potential solution is to apply dynamic runtime changes. However, it is challenging for humans to continuously monitor and manually self-optimize the executions. In this paper, we propose self-adaptiveness of the parallel patterns used, enabling flexible on-the-fly adaptations. The proposed solution is evaluated with an existing programming framework and running experiments with a synthetic and a real-world application. The results show that the proposed solution is able to dynamically self-adapt to the most suitable parallel pattern configuration and achieve performance competitive with the best static cases. The feasibility of the proposed solution encourages future optimizations and other applicabilities.},
keywords = {Self-adaptation, Stream processing},
pubstate = {published},
tppubtype = {inproceedings}
}

@article{VOGEL:SPE:21,
title = {Providing High-level Self-adaptive Abstractions for Stream Parallelism on Multi-cores},
author = {Adriano Vogel and Dalvan Griebler and Luiz Gustavo Fernandes},
doi = {10.1002/spe.2948},
year = {2021},
date = {2021-01-01},
journal = {Software: Practice and Experience},
volume = {51},
number = {6},
pages = {1194-1217},
publisher = {Wiley Online Library},
abstract = {Stream processing applications are common computing workloads that demand parallelism to increase their performance. As in the past, parallel programming remains a difficult task for application programmers. The complexity increases when application programmers must set non-intuitive parallelism parameters, i.e. the degree of parallelism. The main problem is that state-of-the-art libraries use a static degree of parallelism and are not sufficiently abstracted for developing stream processing applications. In this paper, we propose a self-adaptive regulation of the degree of parallelism to provide higher-level abstractions. Flexibility is provided to programmers with two new self-adaptive strategies, one is for performance experts, and the other abstracts the need to set a performance goal. We evaluated our solution using compiler transformation rules to generate parallel code with the SPar domain-specific language. The experimental results with real-world applications highlighted higher abstraction levels without significant performance degradation in comparison to static executions. The strategy for performance experts achieved slightly higher performance than the one that works without user-defined performance goals.},
keywords = {Self-adaptation, Stream processing},
pubstate = {published},
tppubtype = {article}
}

@inproceedings{VOGEL:adaptive-overhead:AutoDaSP:19,
title = {Minimizing Self-Adaptation Overhead in Parallel Stream Processing for Multi-Cores},
author = {Adriano Vogel and Dalvan Griebler and Marco Danelutto and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1007/978-3-030-48340-1_3},
doi = {10.1007/978-3-030-48340-1_3},
year = {2019},
date = {2019-08-01},
booktitle = {Euro-Par 2019: Parallel Processing Workshops},
volume = {11997},
pages = {12},
publisher = {Springer},
address = {Göttingen, Germany},
series = {Lecture Notes in Computer Science},
abstract = {Stream processing paradigm is present in several applications that apply computations over continuous data flowing in the form of streams (e.g., video feeds, image, and data analytics). Employing self-adaptivity to stream processing applications can provide higher-level programming abstractions and autonomic resource management. However, there are cases where the performance is suboptimal. In this paper, the goal is to optimize parallelism adaptations in terms of stability and accuracy, which can improve the performance of parallel stream processing applications. Therefore, we present a new optimized self-adaptive strategy that is experimentally evaluated. The proposed solution provided high-level programming abstractions, reduced the adaptation overhead, and achieved a competitive performance with the best static executions.},
keywords = {Self-adaptation, Stream processing},
pubstate = {published},
tppubtype = {inproceedings}
}

@article{GRIEBLER:JS:19,
title = {Simplifying and implementing service level objectives for stream parallelism},
author = {Dalvan Griebler and Adriano Vogel and Daniele {De Sensi} and Marco Danelutto and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1007/s11227-019-02914-6},
doi = {10.1007/s11227-019-02914-6},
issn = {0920-8542},
year = {2019},
date = {2019-06-01},
journal = {Journal of Supercomputing},
volume = {76},
pages = {4603-4628},
publisher = {Springer},
abstract = {An increasing attention has been given to provide service level objectives (SLOs) in stream processing applications due to the performance and energy requirements, and because of the need to impose limits in terms of resource usage while improving the system utilization. Since the current and next-generation computing systems are intrinsically offering parallel architectures, the software has to naturally exploit the architecture parallelism. Implement and meet SLOs on existing applications is not a trivial task for application programmers, since the software development process, besides the parallelism exploitation, requires the implementation of autonomic algorithms or strategies. This is a system-oriented programming approach and requires the management of multiple knobs and sensors (e.g., the number of threads to use, the clock frequency of the cores, etc.) so that the system can self-adapt at runtime. In this work, we introduce a new and simpler way to define SLO in the application’s source code, by abstracting from the programmer all the details relative to self-adaptive system implementation. The application programmer specifies which parts of the code to parallelize and the related SLOs that should be enforced. To reach this goal, source-to-source code transformation rules are implemented in our compiler, which automatically generates self-adaptive strategies to enforce, at runtime, the user-expressed objectives. The experiments highlighted promising results with simpler, effective, and efficient SLO implementations for real-world applications.},
keywords = {Self-adaptation, Stream processing},
pubstate = {published},
tppubtype = {article}
}

@inproceedings{VOGEL:Adaptive-Latency-SPar:AutoDaSP:18,
title = {Autonomic and Latency-Aware Degree of Parallelism Management in SPar},
author = {Adriano Vogel and Dalvan Griebler and Daniele {De Sensi} and Marco Danelutto and Luiz Gustavo Fernandes},
url = {http://dx.doi.org/10.1007/978-3-030-10549-5_3},
doi = {10.1007/978-3-030-10549-5_3},
year = {2018},
date = {2018-08-01},
booktitle = {Euro-Par 2018: Parallel Processing Workshops},
pages = {28-39},
publisher = {Springer},
address = {Turin, Italy},
series = {Lecture Notes in Computer Science},
abstract = {Stream processing applications became a representative workload in current computing systems. A significant part of these applications demands parallelism to increase performance. However, programmers are often facing a trade-off between coding productivity and performance when introducing parallelism. SPar was created for balancing this trade-off to the application programmers by using the C++11 attributes’ annotation mechanism. In SPar and other programming frameworks for stream processing applications, the manual definition of the number of replicas to be used for the stream operators is a challenge. In addition to that, low latency is required by several stream processing applications. We noted that explicit latency requirements are poorly considered on the state-of-the-art parallel programming frameworks. Since there is a direct relationship between the number of replicas and the latency of the application, in this work we propose an autonomic and adaptive strategy to choose the proper number of replicas in SPar to address latency constraints. We experimentally evaluated our implemented strategy and demonstrated its effectiveness on a real-world application, demonstrating that our adaptive strategy can provide higher abstraction levels while automatically managing the latency.},
keywords = {Self-adaptation, Stream processing},
pubstate = {published},
tppubtype = {inproceedings}
}