@inproceedings{GARCIA:PDP:21,
title = {Introducing a Stream Processing Framework for Assessing Parallel Programming Interfaces},
author = {Adriano Marques Garcia and Dalvan Griebler and Claudio Schepke and Luiz Gustavo Fernandes},
year = {2021},
date = {2021-03-01},
booktitle = {29th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)},
publisher = {IEEE},
address = {Valladolid, Spain},
series = {PDP'21},
abstract = {Stream Processing applications are spread across different sectors of industry and people's daily lives. The increasing data we produce, such as audio, video, image, and text are demanding quickly and efficiently computation. It can be done through Stream Parallelism, which is still a challenging task and most reserved for experts. We introduce a Stream Processing framework for assessing Parallel Programming Interfaces (PPIs). Our framework targets multi-core architectures and C++ stream processing applications, providing an API that abstracts the details of the stream operators of these applications. Therefore, users can easily identify all the basic operators and implement parallelism through different PPIs. In this paper, we present the proposed framework, implement three applications using its API, and show how it works, by using it to parallelize and evaluate the applications with the PPIs Intel TBB, FastFlow, and SPar. The performance results were consistent with the literature.},
keywords = {},
pubstate = {forthcoming},
tppubtype = {inproceedings}
}

@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},
year = {2021},
date = {2021-03-01},
booktitle = {29th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)},
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 = {},
pubstate = {forthcoming},
tppubtype = {inproceedings}
}

@article{VOGEL:SPE:21,
title = {Providing High‐Level Self‐Adaptive Abstractions for Stream Parallelism on Multicores},
author = {Adriano Vogel and Dalvan Griebler and Luiz G Fernandes},
url = {https://doi.org/10.1002/spe.2948},
doi = {10.1002/spe.2948},
year = {2021},
date = {2021-01-01},
journal = {Software: Practice and Experience},
volume = {na},
number = {na},
pages = {na},
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 = {},
pubstate = {published},
tppubtype = {article}
}

@article{BORDIN:IEEEAccess:20,
title = {DSPBench: a Suite of Benchmark Applications for Distributed Data Stream Processing Systems},
author = {Maycon Viana Bordin and Dalvan Griebler and Gabriele Mencagli and Claudio F R Geyer and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1109/ACCESS.2020.3043948},
doi = {10.1109/ACCESS.2020.3043948},
year = {2020},
date = {2020-12-01},
journal = {IEEE Access},
volume = {8},
number = {na},
pages = {222900-222917},
publisher = {IEEE},
abstract = {Systems enabling the continuous processing of large data streams have recently attracted the attention of the scientific community and industrial stakeholders. Data Stream Processing Systems (DSPSs) are complex and powerful frameworks able to ease the development of streaming applications in distributed computing environments like clusters and clouds. Several systems of this kind have been released and currently maintained as open source projects, like Apache Storm and Spark Streaming. Some benchmark applications have often been used by the scientific community to test and evaluate new techniques to improve the performance and usability of DSPSs. However, the existing benchmark suites lack of representative workloads coming from the wide set of application domains that can leverage the benefits offered by the stream processing paradigm in terms of near real-time performance. The goal of this paper is to present a new benchmark suite composed of 15 applications coming from areas like Finance, Telecommunications, Sensor Networks, Social Networks and others. This paper describes in detail the nature of these applications, their full workload characterization in terms of selectivity, processing cost, input size and overall memory occupation. In addition, it exemplifies the usefulness of our benchmark suite to compare real DSPSs by selecting Apache Storm and Spark Streaming for this analysis.},
keywords = {},
pubstate = {published},
tppubtype = {article}
}

@inproceedings{HOFFMANN:SBLP:20,
title = {Stream Parallelism Annotations for Multi-Core Frameworks},
author = {Renato B. Hoffmann and Dalvan Griebler and Marco Danelutto and Luiz Gustavo Fernandes},
url = {https://doi.org/10.1145/3427081.3427088},
doi = {10.1145/3427081.3427088},
year = {2020},
date = {2020-10-01},
booktitle = {XXIV Brazilian Symposium on Programming Languages (SBLP)},
pages = {48-55},
publisher = {ACM},
address = {Natal, Brazil},
series = {SBLP'20},
abstract = {Data generation, collection, and processing is an important workload of modern computer architectures. Stream or high-intensity data flow applications are commonly employed in extracting and interpreting the information contained in this data. Due to the computational complexity of these applications, high-performance ought to be achieved using parallel computing. Indeed, the efficient exploitation of available parallel resources from the architecture remains a challenging task for the programmers. Techniques and methodologies are required to help shift the efforts from the complexity of parallelism exploitation to specific algorithmic solutions. To tackle this problem, we propose a methodology that provides the developer with a suitable abstraction layer between a clean and effective parallel programming interface targeting different multi-core parallel programming frameworks. We used standard C++ code annotations that may be inserted in the source code by the programmer. Then, a compiler parses C++ code with the annotations and generates calls to the desired parallel runtime API. Our experiments demonstrate the feasibility of our methodology and the performance of the abstraction layer, where the difference is negligible in four applications with respect to the state-of-the-art C++ parallel programming frameworks. Additionally, our methodology allows improving the application performance since the developers can choose the runtime that best performs in their system.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}