DQL

Update: This tool is no longer maintained and supported.

Descartes Query Language

Available approaches for performance prediction are usually based on their own modeling formalism and analysis tools. Users are forced to gain detailed knowledge about these approaches before predictions can be made. To lower these efforts, intermediate modeling approaches simplify the preparation and triggering of performance predictions. However, users still have to work with different tools suffering from integration, providing non-unified interfaces and the lack of interfaces to trigger performance predictions automatically.

Our approach is to provide the Descartes Query Language capable of expressing queries for questions like “What is the response time of service X?”. Previous shortcomings are addressed by an interface to integrate different tools. The interface is accessible through a unified query language to trigger performance predictions. The design of the query language is based on a classification scheme with an implementation of an extensible architecture aiming to integrate a broad range of tools and third-party extensions. More information can be found on the following pages:

Download (DQL core + several connectors)
Language
Architecture

If you have any questions, please contact Jürgen Walter.

Mailing List

To stay updated on our tools, please subscribe to our descartes-tools mailing list (low traffic, only announcements related to our tools)

Publications

2018[ to top ]

Tools for Declarative Performance Engineering. J. Walter; S. Eismann; J. Grohmann; D. Okanovic; S. Kounev; in Companion of the 2018 ACM/SPEC International Conference on Performance Engineering (2018). 53–56.
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
- [ URL ]
- [ DOI ]
Performance is of particular relevance to software system design, operation, and evolution. However, the application of performance engineering approaches to solve a given user concern is challenging and requires expert knowledge. In this tutorial paper, we guide the reader step-by-step through the answering of performance concerns following the idea of declarative performance engineering. We explain tools available online, which can be used for automating huge parts of the software performance engineering process. In particular, we present a performance concern language, for which we provide automated answering and visualization referring to measurement-based and model-based analysis. We also detail how to derive performance models using automated extraction of architectural performance models and modeling of parametric dependencies.

@inproceedings{WaEiGrOkKo2018-ICPE-Tools-for-DPE-Tutorial, abstract = {Performance is of particular relevance to software system design, operation, and evolution. However, the application of performance engineering approaches to solve a given user concern is challenging and requires expert knowledge. In this tutorial paper, we guide the reader step-by-step through the answering of performance concerns following the idea of declarative performance engineering. We explain tools available online, which can be used for automating huge parts of the software performance engineering process. In particular, we present a performance concern language, for which we provide automated answering and visualization referring to measurement-based and model-based analysis. We also detail how to derive performance models using automated extraction of architectural performance models and modeling of parametric dependencies.}, address = {New York, NY, USA}, author = {Walter, J{\"u}rgen and Eismann, Simon and Grohmann, Johannes and Okanovic, Dusan and Kounev, Samuel}, booktitle = {Companion of the 2018 ACM/SPEC International Conference on Performance Engineering}, keywords = {DQL}, pages = {53–56}, publisher = {Association for Computing Machinery (ACM)}, series = {ICPE '18}, title = {{Tools for Declarative Performance Engineering}}, year = 2018 }

%0 Conference Paper %1 WaEiGrOkKo2018-ICPE-Tools-for-DPE-Tutorial %A Walter, Jürgen %A Eismann, Simon %A Grohmann, Johannes %A Okanovic, Dusan %A Kounev, Samuel %B Companion of the 2018 ACM/SPEC International Conference on Performance Engineering %C New York, NY, USA %D 2018 %I Association for Computing Machinery (ACM) %P 53--56 %R 10.1145/3185768.3185777 %T Tools for Declarative Performance Engineering %U https://doi.org/10.1145/3185768.3185777 %X Performance is of particular relevance to software system design, operation, and evolution. However, the application of performance engineering approaches to solve a given user concern is challenging and requires expert knowledge. In this tutorial paper, we guide the reader step-by-step through the answering of performance concerns following the idea of declarative performance engineering. We explain tools available online, which can be used for automating huge parts of the software performance engineering process. In particular, we present a performance concern language, for which we provide automated answering and visualization referring to measurement-based and model-based analysis. We also detail how to derive performance models using automated extraction of architectural performance models and modeling of parametric dependencies. %@ 9781450356299

2017[ to top ]

Automated and Adaptable Decision Support for Software Performance Engineering. J. Walter; A. van Hoorn; S. Kounev; in Proceedings of the 11th EAI International Conference on Performance Evaluation Methodologies and Tools (2017).
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
Software performance engineering (SPE) provides a plethora of methods and tooling for measuring, modeling, and evaluating performance properties of software systems. The solution approaches come with different strengths and limitations concerning, for example, accuracy, time-to-result, or system overhead. While approaches allow for interchangeability, the choice of an appropriate approach and tooling to solve a given performance concern still relies on expert knowledge. Currently, there is no automated and extensible approach for decision support. In this paper, we present a methodology for the automated selection of performance engineering approaches tailored to user concerns. We decouple the complexity of selecting an SPE approach for a given scenario providing a decision engine and solution approach capability models. This separation allows to easily append additional solution approaches and rating criteria. We demonstrate the applicability by presenting decision engines that compare measurement- and model-based analysis approaches.

@inproceedings{WalterHoKo2017-DecisionSupport, abstract = {Software performance engineering (SPE) provides a plethora of methods and tooling for measuring, modeling, and evaluating performance properties of software systems. The solution approaches come with different strengths and limitations concerning, for example, accuracy, time-to-result, or system overhead. While approaches allow for interchangeability, the choice of an appropriate approach and tooling to solve a given performance concern still relies on expert knowledge. Currently, there is no automated and extensible approach for decision support. In this paper, we present a methodology for the automated selection of performance engineering approaches tailored to user concerns. We decouple the complexity of selecting an SPE approach for a given scenario providing a decision engine and solution approach capability models. This separation allows to easily append additional solution approaches and rating criteria. We demonstrate the applicability by presenting decision engines that compare measurement- and model-based analysis approaches.}, author = {Walter, J{\"u}rgen and van Hoorn, Andre and Kounev, Samuel}, booktitle = {Proceedings of the 11th EAI International Conference on Performance Evaluation Methodologies and Tools}, keywords = {DQL}, month = 12, title = {{Automated and Adaptable Decision Support for Software Performance Engineering}}, year = 2017 }

%0 Conference Paper %1 WalterHoKo2017-DecisionSupport %A Walter, Jürgen %A van Hoorn, Andre %A Kounev, Samuel %B Proceedings of the 11th EAI International Conference on Performance Evaluation Methodologies and Tools %D 2017 %T Automated and Adaptable Decision Support for Software Performance Engineering %X Software performance engineering (SPE) provides a plethora of methods and tooling for measuring, modeling, and evaluating performance properties of software systems. The solution approaches come with different strengths and limitations concerning, for example, accuracy, time-to-result, or system overhead. While approaches allow for interchangeability, the choice of an appropriate approach and tooling to solve a given performance concern still relies on expert knowledge. Currently, there is no automated and extensible approach for decision support. In this paper, we present a methodology for the automated selection of performance engineering approaches tailored to user concerns. We decouple the complexity of selecting an SPE approach for a given scenario providing a decision engine and solution approach capability models. This separation allows to easily append additional solution approaches and rating criteria. We demonstrate the applicability by presenting decision engines that compare measurement- and model-based analysis approaches.
Mapping of Service Level Objectives to Performance Queries. J. Walter; D. Okanovic; S. Kounev; in Proceedings of the 2017 Workshop on Challenges in Performance Methods for Software Development (WOSP-C’17) co-located with 8th ACM/SPEC International Conference on Performance Engineering (ICPE 2017) (2017).
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
The concept of service level agreements (SLAs) defines the idea of a reliable contract between service providers and their users. SLAs provide information on the scope, the quality and the responsibilities of a service and its provider. Service level objectives (SLOs) define the detailed, measurable conditions of the SLAs. After service deployment, SLAs are monitored, to assess potentially dangerous situations, that further lead to violation of the SLAs. However, the SLA monitoring infrastructure is usually specific to the underlying system infrastructure, lacks generalization, and is often limited to measurement-based approaches. This makes it hard to apply the results from SLA monitoring in other stages of the software life-cycle. In this paper we propose the mapping of concerns defined in SLAs to the performance metrics queries using the Descartes Query Language (DQL). The benefit of our approach is that the same performance query can then be reused for evaluation of performance concerns throughout the entire life-cycle, and regardless of which approach is used for evaluation.

@inproceedings{WaOkKo2017-WOSPC-SLO2Queries, abstract = {The concept of service level agreements (SLAs) defines the idea of a reliable contract between service providers and their users. SLAs provide information on the scope, the quality and the responsibilities of a service and its provider. Service level objectives (SLOs) define the detailed, measurable conditions of the SLAs. After service deployment, SLAs are monitored, to assess potentially dangerous situations, that further lead to violation of the SLAs. However, the SLA monitoring infrastructure is usually specific to the underlying system infrastructure, lacks generalization, and is often limited to measurement-based approaches. This makes it hard to apply the results from SLA monitoring in other stages of the software life-cycle. In this paper we propose the mapping of concerns defined in SLAs to the performance metrics queries using the Descartes Query Language (DQL). The benefit of our approach is that the same performance query can then be reused for evaluation of performance concerns throughout the entire life-cycle, and regardless of which approach is used for evaluation.}, author = {Walter, J{\"u}rgen and Okanovic, Dusan and Kounev, Samuel}, booktitle = {{Proceedings of the 2017 Workshop on Challenges in Performance Methods for Software Development (WOSP-C'17) co-located with 8th ACM/SPEC International Conference on Performance Engineering (ICPE 2017)}}, keywords = {DQL}, month = {04}, publisher = {ACM}, title = {{Mapping of Service Level Objectives to Performance Queries}}, year = 2017 }

%0 Conference Paper %1 WaOkKo2017-WOSPC-SLO2Queries %A Walter, Jürgen %A Okanovic, Dusan %A Kounev, Samuel %B Proceedings of the 2017 Workshop on Challenges in Performance Methods for Software Development (WOSP-C'17) co-located with 8th ACM/SPEC International Conference on Performance Engineering (ICPE 2017) %D 2017 %I ACM %T Mapping of Service Level Objectives to Performance Queries %X The concept of service level agreements (SLAs) defines the idea of a reliable contract between service providers and their users. SLAs provide information on the scope, the quality and the responsibilities of a service and its provider. Service level objectives (SLOs) define the detailed, measurable conditions of the SLAs. After service deployment, SLAs are monitored, to assess potentially dangerous situations, that further lead to violation of the SLAs. However, the SLA monitoring infrastructure is usually specific to the underlying system infrastructure, lacks generalization, and is often limited to measurement-based approaches. This makes it hard to apply the results from SLA monitoring in other stages of the software life-cycle. In this paper we propose the mapping of concerns defined in SLAs to the performance metrics queries using the Descartes Query Language (DQL). The benefit of our approach is that the same performance query can then be reused for evaluation of performance concerns throughout the entire life-cycle, and regardless of which approach is used for evaluation.
Model-Based Self-Aware Performance and Resource Management Using the Descartes Modeling Language. N. Huber; F. Brosig; S. Spinner; S. Kounev; M. Bähr; in IEEE Transactions on Software Engineering (TSE) (2017). 43(5) 432–452.
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
- [ URL ]
Modern IT systems have increasingly distributed and dynamic architectures providing flexibility to adapt to changes in the environment and thus enabling higher resource efficiency. However, these benefits come at the cost of higher system complexity and dynamics. Thus, engineering systems that manage their end-to-end application performance and resource efficiency in an autonomic manner is a challenge. In this article, we present a holistic model-based approach for self-aware performance and resource management leveraging the Descartes Modeling Language (DML), an architecture-level modeling language for online performance and resource management. We propose a novel online performance prediction process that dynamically tailors the model solving depending on the requirements regarding accuracy and overhead. Using these prediction capabilities, we implement a generic model-based control loop for proactive system adaptation. We evaluate our model-based approach in the context of two representative case studies showing that with the proposed methods, significant resource efficiency gains can be achieved while maintaining performance requirements. These results represent the first end-to-end validation of our approach, demonstrating its potential for self-aware performance and resource management in the context of modern IT systems and infrastructures.

@article{HuBrSpKoBa2017-TSE-DML, abstract = {Modern IT systems have increasingly distributed and dynamic architectures providing flexibility to adapt to changes in the environment and thus enabling higher resource efficiency. However, these benefits come at the cost of higher system complexity and dynamics. Thus, engineering systems that manage their end-to-end application performance and resource efficiency in an autonomic manner is a challenge. In this article, we present a holistic model-based approach for self-aware performance and resource management leveraging the Descartes Modeling Language (DML), an architecture-level modeling language for online performance and resource management. We propose a novel online performance prediction process that dynamically tailors the model solving depending on the requirements regarding accuracy and overhead. Using these prediction capabilities, we implement a generic model-based control loop for proactive system adaptation. We evaluate our model-based approach in the context of two representative case studies showing that with the proposed methods, significant resource efficiency gains can be achieved while maintaining performance requirements. These results represent the first end-to-end validation of our approach, demonstrating its potential for self-aware performance and resource management in the context of modern IT systems and infrastructures.}, author = {Huber, Nikolaus and Brosig, Fabian and Spinner, Simon and Kounev, Samuel and B{\"a}hr, Manuel}, journal = {IEEE Transactions on Software Engineering (TSE)}, keywords = {DQL}, number = 5, pages = {432–452}, publisher = {IEEE Computer Society}, title = {{Model-Based Self-Aware Performance and Resource Management Using the Descartes Modeling Language}}, volume = 43, year = 2017 }

%0 Journal Article %1 HuBrSpKoBa2017-TSE-DML %A Huber, Nikolaus %A Brosig, Fabian %A Spinner, Simon %A Kounev, Samuel %A Bähr, Manuel %D 2017 %I IEEE Computer Society %J IEEE Transactions on Software Engineering (TSE) %N 5 %P 432--452 %T Model-Based Self-Aware Performance and Resource Management Using the Descartes Modeling Language %U http://dx.doi.org/10.1109/TSE.2016.2613863 %V 43 %X Modern IT systems have increasingly distributed and dynamic architectures providing flexibility to adapt to changes in the environment and thus enabling higher resource efficiency. However, these benefits come at the cost of higher system complexity and dynamics. Thus, engineering systems that manage their end-to-end application performance and resource efficiency in an autonomic manner is a challenge. In this article, we present a holistic model-based approach for self-aware performance and resource management leveraging the Descartes Modeling Language (DML), an architecture-level modeling language for online performance and resource management. We propose a novel online performance prediction process that dynamically tailors the model solving depending on the requirements regarding accuracy and overhead. Using these prediction capabilities, we implement a generic model-based control loop for proactive system adaptation. We evaluate our model-based approach in the context of two representative case studies showing that with the proposed methods, significant resource efficiency gains can be achieved while maintaining performance requirements. These results represent the first end-to-end validation of our approach, demonstrating its potential for self-aware performance and resource management in the context of modern IT systems and infrastructures.

2016[ to top ]

Kieker4DQL: Declarative Performance Measurement. M. Blohm; M. Pahlberg; S. Vogel; J. Walter; D. Okanovic; in Proceedings of the 2016 Symposium on Software Performance (SSP) (2016).
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
The Descartes Query Language (DQL) enables to query the performance of a system using adapters to various solution approaches. Thereby, DQL is a realization of the vision of Declarative Performance Engineering (DPE) which decouples the description of user concerns (performance questions and goals) from the task of selecting and applying a speciffic solution approach. While model-based approaches are already supported by DQL, measurement based approaches are not. In this paper we present the Kieker4DQL, an adapter for DQL that performs query processing for Application Monitoring Tools, the Kieker in particular. It creates a tailored monitoring configuration to start measurements. The resulting monitoring data is filtered and interpreted according to the query.

@inproceedings{BlPhVoWaOk2016-SPP-Kieker4DQL, abstract = {The Descartes Query Language (DQL) enables to query the performance of a system using adapters to various solution approaches. Thereby, DQL is a realization of the vision of Declarative Performance Engineering (DPE) which decouples the description of user concerns (performance questions and goals) from the task of selecting and applying a speciffic solution approach. While model-based approaches are already supported by DQL, measurement based approaches are not. In this paper we present the Kieker4DQL, an adapter for DQL that performs query processing for Application Monitoring Tools, the Kieker in particular. It creates a tailored monitoring configuration to start measurements. The resulting monitoring data is filtered and interpreted according to the query.}, author = {Blohm, Matthias and Pahlberg, Maksim and Vogel, Sebastian and Walter, J{\"u}rgen and Okanovic, Dusan}, booktitle = {Proceedings of the 2016 Symposium on Software Performance (SSP)}, keywords = {DQL}, month = 11, title = {{ Kieker4DQL: Declarative Performance Measurement}}, year = 2016 }

%0 Conference Paper %1 BlPhVoWaOk2016-SPP-Kieker4DQL %A Blohm, Matthias %A Pahlberg, Maksim %A Vogel, Sebastian %A Walter, Jürgen %A Okanovic, Dusan %B Proceedings of the 2016 Symposium on Software Performance (SSP) %D 2016 %T Kieker4DQL: Declarative Performance Measurement %X The Descartes Query Language (DQL) enables to query the performance of a system using adapters to various solution approaches. Thereby, DQL is a realization of the vision of Declarative Performance Engineering (DPE) which decouples the description of user concerns (performance questions and goals) from the task of selecting and applying a speciffic solution approach. While model-based approaches are already supported by DQL, measurement based approaches are not. In this paper we present the Kieker4DQL, an adapter for DQL that performs query processing for Application Monitoring Tools, the Kieker in particular. It creates a tailored monitoring configuration to start measurements. The resulting monitoring data is filtered and interpreted according to the query.
PAVO: A Framework for the Visualization of Performance Analyses Results. J. Walter; M. König; S. Eismann; S. Kounev; in Proceedings of the 2016 Symposium on Software Performance (SSP) (2016).
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
Awareness of application performance can be derived through various quantitative analyses, model-based and measurement-based approaches. A suitable visualization supports the understanding of application performance. Usually, analysis tools include a tool specific visualization or no visualization at all. In this paper we proposed to decouple the result visualization from the analysis approach. We present the Performance VisualizatiOn (PAVO) framework which provides result visualization tailored to a given performance analysis result. To show benefits and usability of PAVO, we present our integration in Descartes Query Language (DQL).

@inproceedings{WaKoEiKo2016-SPP-PAVO, abstract = {Awareness of application performance can be derived through various quantitative analyses, model-based and measurement-based approaches. A suitable visualization supports the understanding of application performance. Usually, analysis tools include a tool specific visualization or no visualization at all. In this paper we proposed to decouple the result visualization from the analysis approach. We present the Performance VisualizatiOn (PAVO) framework which provides result visualization tailored to a given performance analysis result. To show benefits and usability of PAVO, we present our integration in Descartes Query Language (DQL).}, author = {Walter, J{\"u}rgen and K{\"o}nig, Maximilian and Eismann, Simon and Kounev, Samuel}, booktitle = {Proceedings of the 2016 Symposium on Software Performance (SSP)}, keywords = {DQL}, month = 11, title = {{ PAVO: A Framework for the Visualization of Performance Analyses Results}}, year = 2016 }

%0 Conference Paper %1 WaKoEiKo2016-SPP-PAVO %A Walter, Jürgen %A König, Maximilian %A Eismann, Simon %A Kounev, Samuel %B Proceedings of the 2016 Symposium on Software Performance (SSP) %D 2016 %T PAVO: A Framework for the Visualization of Performance Analyses Results %X Awareness of application performance can be derived through various quantitative analyses, model-based and measurement-based approaches. A suitable visualization supports the understanding of application performance. Usually, analysis tools include a tool specific visualization or no visualization at all. In this paper we proposed to decouple the result visualization from the analysis approach. We present the Performance VisualizatiOn (PAVO) framework which provides result visualization tailored to a given performance analysis result. To show benefits and usability of PAVO, we present our integration in Descartes Query Language (DQL).
Extending the Descartes Query Language to Support Automated What-If Analysis. A. Knapp; Thesis; University of Würzburg; Am Hubland, Informatikgebäude, 97074 Würzburg, Germany. (2016, August).
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
For modern systems, performance engineering is important. Performance Engineering is quite difficult because there are many different analysis aproaches. The Descartes Query Language has been developed to support an easy usage of performance analysis approaches. It enables the user to separate the definition of the users concern and its deduction. In this thesis, DQL gets an extension to support "What if...?" analyses. WhatIFQueries are designed to be as simple and short as possible as they require less knowledge about the system/model of the user than existing query types. Still, they allow more complex structures to get different result outputs. This thesis contributes to query for all parameter changes without the need of specifying them. It also adds filtering mechanisms and functionality to automatically compare internal and external variations to current state. The evaluation for the implementation was done with connectors for several solution approaches and provides unit tests.

@mastersthesis{Knapp2016, abstract = {For modern systems, performance engineering is important. Performance Engineering is quite difficult because there are many different analysis aproaches. The Descartes Query Language has been developed to support an easy usage of performance analysis approaches. It enables the user to separate the definition of the users concern and its deduction. In this thesis, DQL gets an extension to support "What if...?" analyses. WhatIFQueries are designed to be as simple and short as possible as they require less knowledge about the system/model of the user than existing query types. Still, they allow more complex structures to get different result outputs. This thesis contributes to query for all parameter changes without the need of specifying them. It also adds filtering mechanisms and functionality to automatically compare internal and external variations to current state. The evaluation for the implementation was done with connectors for several solution approaches and provides unit tests.}, address = {Am Hubland, Informatikgeb{\"a}ude, 97074 W{\"u}rzburg, Germany}, author = {Knapp, Andreas}, keywords = {DQL}, month = {08}, school = {University of W{\"u}rzburg}, title = {{Extending the Descartes Query Language to Support Automated What-If Analysis}}, type = {{Bachelor Thesis}}, year = 2016 }

%0 Thesis %1 Knapp2016 %A Knapp, Andreas %C Am Hubland, Informatikgebäude, 97074 Würzburg, Germany %D 2016 %T Extending the Descartes Query Language to Support Automated What-If Analysis %X For modern systems, performance engineering is important. Performance Engineering is quite difficult because there are many different analysis aproaches. The Descartes Query Language has been developed to support an easy usage of performance analysis approaches. It enables the user to separate the definition of the users concern and its deduction. In this thesis, DQL gets an extension to support "What if...?" analyses. WhatIFQueries are designed to be as simple and short as possible as they require less knowledge about the system/model of the user than existing query types. Still, they allow more complex structures to get different result outputs. This thesis contributes to query for all parameter changes without the need of specifying them. It also adds filtering mechanisms and functionality to automatically compare internal and external variations to current state. The evaluation for the implementation was done with connectors for several solution approaches and provides unit tests.
Die Suche nach der Antwortmaschine. K. Fehr; (2016, Juni).
- [ BibTeX ]
- [ EndNote ]
- [ URL ]
@misc{pressEinblickDECLARE2016, author = {{Karsten Fehr}}, howpublished = {einBLICK}, keywords = {DQL}, month = {06}, note = {http://www.presse.uni-wuerzburg.de/einblick/single/artikel/die-suche-nach-der-antwortmaschine/}, title = {{Die Suche nach der Antwortmaschine}}, year = 2016 }

%0 Generic %1 pressEinblickDECLARE2016 %A Fehr, Karsten %D 2016 %T Die Suche nach der Antwortmaschine %U http://www.presse.uni-wuerzburg.de/einblick/single/artikel/die-suche-nach-der-antwortmaschine/
Automation and Simplification Through Declarative Performance Engineering. J. Walter; (2016, Juni).
- [ BibTeX ]
- [ EndNote ]
@misc{Talk-Kolloquium-2016-06-14, address = {W{\"u}rzburg, Germany}, author = {Walter, J{\"u}rgen}, howpublished = {Doctoral Colloquium W{\"u}rzburg, June 14, 2016}, keywords = {Optimization}, month = {06}, title = {{Automation and Simplification Through Declarative Performance Engineering}}, year = 2016 }

%0 Generic %1 Talk-Kolloquium-2016-06-14 %A Walter, Jürgen %C Würzburg, Germany %D 2016 %T Automation and Simplification Through Declarative Performance Engineering
The Vision of Declarative Performance Engineering. J. Walter; A. van Hoorn; H. Koziolek; D. Okanovic; S. Kounev; in Proceedings of the 7th ACM/SPEC International Conference on Performance Engineering (ICPE 2016) (2016).
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
Over the past decades, various methods, techniques, and tools for modeling and evaluating performance properties of software systems have been proposed covering the entire software life cycle. However, the application of performance engineering approaches to solve a given user concern is still rather challenging and requires expert knowledge and experience. There are no recipes on how to select, configure, and execute suitable methods, tools, and techniques allowing to address the user concerns. In this paper, we describe our vision of Declarative Performance Engineering (DPE), which aims to decouple the description of the user concerns to be solved (performance questions and goals) from the task of selecting and applying a specific solution approach. The strict separation of ``what'' versus ``how'' enables the development of different techniques and algorithms to automatically select and apply a suitable approach for a given scenario. The goal is to hide complexity from the user by allowing users to express their concerns and goals without requiring any knowledge about performance engineering techniques. Towards realizing the DPE vision, we discuss the different requirements and propose a reference architecture for implementing and integrating respective methods, algorithms, and tooling.

@inproceedings{WaHoKoOkKo2016-ICPE-DPE_Poster, abstract = {Over the past decades, various methods, techniques, and tools for modeling and evaluating performance properties of software systems have been proposed covering the entire software life cycle. However, the application of performance engineering approaches to solve a given user concern is still rather challenging and requires expert knowledge and experience. There are no recipes on how to select, configure, and execute suitable methods, tools, and techniques allowing to address the user concerns. In this paper, we describe our vision of Declarative Performance Engineering (DPE), which aims to decouple the description of the user concerns to be solved (performance questions and goals) from the task of selecting and applying a specific solution approach. The strict separation of ``what'' versus ``how'' enables the development of different techniques and algorithms to automatically select and apply a suitable approach for a given scenario. The goal is to hide complexity from the user by allowing users to express their concerns and goals without requiring any knowledge about performance engineering techniques. Towards realizing the DPE vision, we discuss the different requirements and propose a reference architecture for implementing and integrating respective methods, algorithms, and tooling.}, author = {Walter, J{\"u}rgen and van Hoorn, Andre and Koziolek, Heiko and Okanovic, Dusan and Kounev, Samuel}, booktitle = {{Proceedings of the 7th ACM/SPEC International Conference on Performance Engineering (ICPE 2016)}}, keywords = {DQL}, month = {03}, title = {{The Vision of Declarative Performance Engineering}}, year = 2016 }

%0 Conference Paper %1 WaHoKoOkKo2016-ICPE-DPE_Poster %A Walter, Jürgen %A van Hoorn, Andre %A Koziolek, Heiko %A Okanovic, Dusan %A Kounev, Samuel %B Proceedings of the 7th ACM/SPEC International Conference on Performance Engineering (ICPE 2016) %D 2016 %T The Vision of Declarative Performance Engineering %X Over the past decades, various methods, techniques, and tools for modeling and evaluating performance properties of software systems have been proposed covering the entire software life cycle. However, the application of performance engineering approaches to solve a given user concern is still rather challenging and requires expert knowledge and experience. There are no recipes on how to select, configure, and execute suitable methods, tools, and techniques allowing to address the user concerns. In this paper, we describe our vision of Declarative Performance Engineering (DPE), which aims to decouple the description of the user concerns to be solved (performance questions and goals) from the task of selecting and applying a specific solution approach. The strict separation of ``what'' versus ``how'' enables the development of different techniques and algorithms to automatically select and apply a suitable approach for a given scenario. The goal is to hide complexity from the user by allowing users to express their concerns and goals without requiring any knowledge about performance engineering techniques. Towards realizing the DPE vision, we discuss the different requirements and propose a reference architecture for implementing and integrating respective methods, algorithms, and tooling.
Asking ``What?’’, Automating the ``How?’’: The Vision of Declarative Performance Engineering. J. Walter; A. van Hoorn; H. Koziolek; D. Okanovic; S. Kounev; in Proceedings of the 7th ACM/SPEC International Conference on Performance Engineering (ICPE 2016) (2016).
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
Over the past decades, various methods, techniques, and tools for modeling and evaluating performance properties of software systems have been proposed covering the entire software life cycle. However, the application of performance engineering approaches to solve a given user concern is still rather challenging and requires expert knowledge and experience. There are no recipes on how to select, configure, and execute suitable methods, tools, and techniques allowing to address the user concerns. In this paper, we describe our vision of Declarative Performance Engineering (DPE), which aims to decouple the description of the user concerns to be solved (performance questions and goals) from the task of selecting and applying a specific solution approach. The strict separation of ``what'' versus ``how'' enables the development of different techniques and algorithms to automatically select and apply a suitable approach for a given scenario. The goal is to hide complexity from the user by allowing users to express their concerns and goals without requiring any knowledge about performance engineering techniques. Towards realizing the DPE vision, we discuss the different requirements and propose a reference architecture for implementing and integrating respective methods, algorithms, and tooling.

@inproceedings{WaHoKoOkKo2016-ICPE-DPE_Vision, abstract = {Over the past decades, various methods, techniques, and tools for modeling and evaluating performance properties of software systems have been proposed covering the entire software life cycle. However, the application of performance engineering approaches to solve a given user concern is still rather challenging and requires expert knowledge and experience. There are no recipes on how to select, configure, and execute suitable methods, tools, and techniques allowing to address the user concerns. In this paper, we describe our vision of Declarative Performance Engineering (DPE), which aims to decouple the description of the user concerns to be solved (performance questions and goals) from the task of selecting and applying a specific solution approach. The strict separation of ``what'' versus ``how'' enables the development of different techniques and algorithms to automatically select and apply a suitable approach for a given scenario. The goal is to hide complexity from the user by allowing users to express their concerns and goals without requiring any knowledge about performance engineering techniques. Towards realizing the DPE vision, we discuss the different requirements and propose a reference architecture for implementing and integrating respective methods, algorithms, and tooling.}, author = {Walter, J{\"u}rgen and van Hoorn, Andre and Koziolek, Heiko and Okanovic, Dusan and Kounev, Samuel}, booktitle = {{Proceedings of the 7th ACM/SPEC International Conference on Performance Engineering (ICPE 2016)}}, keywords = {DQL}, month = {03}, title = {{Asking ``What?'', Automating the ``How?'': The Vision of Declarative Performance Engineering}}, year = 2016 }

%0 Conference Paper %1 WaHoKoOkKo2016-ICPE-DPE_Vision %A Walter, Jürgen %A van Hoorn, Andre %A Koziolek, Heiko %A Okanovic, Dusan %A Kounev, Samuel %B Proceedings of the 7th ACM/SPEC International Conference on Performance Engineering (ICPE 2016) %D 2016 %T Asking ``What?'', Automating the ``How?'': The Vision of Declarative Performance Engineering %X Over the past decades, various methods, techniques, and tools for modeling and evaluating performance properties of software systems have been proposed covering the entire software life cycle. However, the application of performance engineering approaches to solve a given user concern is still rather challenging and requires expert knowledge and experience. There are no recipes on how to select, configure, and execute suitable methods, tools, and techniques allowing to address the user concerns. In this paper, we describe our vision of Declarative Performance Engineering (DPE), which aims to decouple the description of the user concerns to be solved (performance questions and goals) from the task of selecting and applying a specific solution approach. The strict separation of ``what'' versus ``how'' enables the development of different techniques and algorithms to automatically select and apply a suitable approach for a given scenario. The goal is to hide complexity from the user by allowing users to express their concerns and goals without requiring any knowledge about performance engineering techniques. Towards realizing the DPE vision, we discuss the different requirements and propose a reference architecture for implementing and integrating respective methods, algorithms, and tooling.

2015[ to top ]

Declarative Automation Framework for QPME based on DQL. S. Eismann; Thesis; University of Würzburg; Am Hubland, Informatikgebäude, 97074 Würzburg, Germany. (2015, März).
- [ BibTeX ]
- [ EndNote ]
@mastersthesis{Eismann2015, address = {Am Hubland, Informatikgeb{\"a}ude, 97074 W{\"u}rzburg, Germany}, author = {Eismann, Simon}, keywords = {QPN}, month = {03}, school = {University of W{\"u}rzburg}, title = {{Declarative Automation Framework for QPME based on DQL}}, type = {{Bachelor Thesis}}, year = 2015 }

%0 Thesis %1 Eismann2015 %A Eismann, Simon %C Am Hubland, Informatikgebäude, 97074 Würzburg, Germany %D 2015 %T Declarative Automation Framework for QPME based on DQL

2014[ to top ]

Performance Queries for Architecture-Level Performance Models. F. Gorsler; F. Brosig; S. Kounev; in Proceedings of the 5th ACM/SPEC International Conference on Performance Engineering (ICPE 2014) (2014).
- [ BibTeX ]
- [ EndNote ]
@inproceedings{GoBrKo2014-PerformanceQueries, address = {New York, NY, USA}, author = {Gorsler, Fabian and Brosig, Fabian and Kounev, Samuel}, booktitle = {Proceedings of the 5th ACM/SPEC International Conference on Performance Engineering (ICPE 2014)}, keywords = {DQL}, month = {{March}}, note = {Acceptance Rate (Full Paper): 14/56 = 25\%.}, publisher = {ACM}, title = {{Performance Queries for Architecture-Level Performance Models}}, year = 2014 }

%0 Conference Paper %1 GoBrKo2014-PerformanceQueries %A Gorsler, Fabian %A Brosig, Fabian %A Kounev, Samuel %B Proceedings of the 5th ACM/SPEC International Conference on Performance Engineering (ICPE 2014) %C New York, NY, USA %D 2014 %I ACM %T Performance Queries for Architecture-Level Performance Models

2013[ to top ]

Controlling the Palladio Bench using the Descartes Query Language. F. Gorsler; F. Brosig; S. Kounev; in Proceedings of the Symposium on Software Performance: Joint Kieker/Palladio Days (KPDAYS 2013), S. Becker, W. Hasselbring, A. van Hoorn, R. Reussner (Hrsg.) (2013). 109–118.
- [ Abstract ]
- [ BibTeX ]
- [ EndNote ]
- [ URL ]
The Palladio Bench is a tool to model, simulate and analyze Palladio Component Model (PCM) instances. However, for the Palladio Bench, no single interface to automate experiments or Application Programming Interface (API) to trigger the simulation of PCM instances and to extract performance prediction results is available. The Descartes Query Language (DQL) is a novel approach of a declarative query language to integrate different performance modeling and prediction techniques behind a unifying interface. Users benefit from the abstraction of specific tools to prepare and trigger performance predictions, less effort to obtain performance metrics of interest, and means to automate performance predictions. In this paper, we describe the realization of a DQL Connector for PCM and demonstrate the applicability of our approach in a case study.

@inproceedings{GoBrKo2013-ControllingPCM, abstract = {The Palladio Bench is a tool to model, simulate and analyze Palladio Component Model (PCM) instances. However, for the Palladio Bench, no single interface to automate experiments or Application Programming Interface (API) to trigger the simulation of PCM instances and to extract performance prediction results is available. The Descartes Query Language (DQL) is a novel approach of a declarative query language to integrate different performance modeling and prediction techniques behind a unifying interface. Users benefit from the abstraction of specific tools to prepare and trigger performance predictions, less effort to obtain performance metrics of interest, and means to automate performance predictions. In this paper, we describe the realization of a DQL Connector for PCM and demonstrate the applicability of our approach in a case study.}, address = {Aachen, Germany}, author = {Gorsler, Fabian and Brosig, Fabian and Kounev, Samuel}, booktitle = {Proceedings of the Symposium on Software Performance: Joint Kieker/Palladio Days (KPDAYS 2013)}, editor = {Becker, Steffen and Hasselbring, Wilhelm and van Hoorn, Andr{\'e} and Reussner, Ralf}, keywords = {Optimization}, month = 11, number = 1083, pages = {109–118}, publisher = {CEUR-WS.org}, title = {Controlling the Palladio Bench using the Descartes Query Language}, year = 2013 }

%0 Conference Paper %1 GoBrKo2013-ControllingPCM %A Gorsler, Fabian %A Brosig, Fabian %A Kounev, Samuel %B Proceedings of the Symposium on Software Performance: Joint Kieker/Palladio Days (KPDAYS 2013) %C Aachen, Germany %D 2013 %E Becker, Steffen %E Hasselbring, Wilhelm %E van Hoorn, André %E Reussner, Ralf %I CEUR-WS.org %N 1083 %P 109--118 %T Controlling the Palladio Bench using the Descartes Query Language %U http://ceur-ws.org/Vol-1083/ %X The Palladio Bench is a tool to model, simulate and analyze Palladio Component Model (PCM) instances. However, for the Palladio Bench, no single interface to automate experiments or Application Programming Interface (API) to trigger the simulation of PCM instances and to extract performance prediction results is available. The Descartes Query Language (DQL) is a novel approach of a declarative query language to integrate different performance modeling and prediction techniques behind a unifying interface. Users benefit from the abstraction of specific tools to prepare and trigger performance predictions, less effort to obtain performance metrics of interest, and means to automate performance predictions. In this paper, we describe the realization of a DQL Connector for PCM and demonstrate the applicability of our approach in a case study.
Online Performance Queries for Architecture-Level Performance Models. F. Gorsler; Thesis; Karlsruhe Institute of Technology (KIT); Am Fasanengarten 5, 76131 Karlsruhe, Germany. (2013, Juli).
- [ BibTeX ]
- [ EndNote ]
@mastersthesis{Gorsler2013a, address = {Am Fasanengarten 5, 76131 Karlsruhe, Germany}, author = {Gorsler, Fabian}, keywords = {DQL}, month = {07}, school = {Karlsruhe Institute of Technology (KIT)}, title = {{Online Performance Queries for Architecture-Level Performance Models}}, year = 2013 }

%0 Thesis %1 Gorsler2013a %A Gorsler, Fabian %C Am Fasanengarten 5, 76131 Karlsruhe, Germany %D 2013 %T Online Performance Queries for Architecture-Level Performance Models

DQL

Update: This tool is no longer maintained and supported.

Descartes Query Language

Mailing List

Publications

Data privacy protection

Data privacy protection

Picture credits

Your E-mail address:
Your Name (optional):