Scientific computation requires more and more performance in its algorithms. New massively parallel
architectures suit well to these algorithms. They are known for offering high performance and power
efficiency. Unfortunately, as parallel programming for these architectures requires a complex distribution
of tasks and data, developers find difficult to implement their applications effectively. Although approaches
based on source-to-source intends to provide a low learning curve for parallel programming and take
advantage of architecture features to create optimized applications, programming remains difficult for
neophytes. This work aims at improving performance by returning to the high-level models, specific
execution data from a profiling tool enhanced by smart advices computed by an analysis engine. In order to
keep the link between execution and model, the process is based on a traceability mechanism. Once the
model is automatically annotated, it can be re-factored aiming better performances on the re-generated
code. Hence, this work allows keeping coherence between model and code without forgetting to harness the
power of parallel architectures. To illustrate and clarify key points of this approach, we provide an
experimental example in GPUs context. The example uses a transformation chain from UML-MARTE
models to OpenCL code.
STATISTICAL ANALYSIS FOR PERFORMANCE COMPARISONijseajournal
Performance responsiveness and scalability is a make-or-break quality for software. Nearly everyone runs into performance problems at one time or another. This paper discusses about performance issues faced during Pre Examination Process Automation System (PEPAS) implemented in java technology. The challenges faced during the life cycle of the project and the mitigation actions performed. It compares 3 java technologies and shows how improvements are made through statistical analysis in response time of the application. The paper concludes with result analysis.
THE UNIFIED APPROACH FOR ORGANIZATIONAL NETWORK VULNERABILITY ASSESSMENTijseajournal
The present business network infrastructure is quickly varying with latest servers, services, connections,
and ports added often, at times day by day, and with a uncontrollably inflow of laptops, storage media and
wireless networks. With the increasing amount of vulnerabilities and exploits coupled with the recurrent
evolution of IT infrastructure, organizations at present require more numerous vulnerability assessments.
In this paper new approach the Unified process for Network vulnerability Assessments hereafter called as
a unified NVA is proposed for network vulnerability assessment derived from Unified Software
Development Process or Unified Process, it is a popular iterative and incremental software development
process framework.
Performance Evaluation using Blackboard Technique in Software ArchitectureEditor IJCATR
Validation of software systems is very useful at the primary stages of their development cycle. Evaluation of functional
requirements is supported by clear and appropriate approaches, but there is no similar strategy for evaluation of non-functional
requirements (such as performance). Whereas establishing the non-functional requirements have significant effect on success of
software systems, therefore considerable necessities are needed for evaluation of non-functional requirements. Also, if the software
performance has been specified based on performance models, may be evaluated at the primary stages of software development cycle.
Therefore, modeling and evaluation of non-functional requirements in software architecture level, that are designed at the primary
stages of software systems development cycle and prior to implementation, will be very effective.
We propose an approach for evaluate the performance of software systems, based on black board technique in software architecture
level. In this approach, at first, software architecture using blackboard technique is described by UML use case, activity and
component diagrams. then UML model is transformed to an executable model based on timed colored petri nets(TCPN)
Consequently, upon execution of an executive model and analysis of its results, non-functional requirements including performance
(such as response time) may be evaluated in software architecture level.
A FRAMEWORK FOR ASPECTUAL REQUIREMENTS VALIDATION: AN EXPERIMENTAL STUDYijseajournal
Requirements engineering is a discipline of software engineering that is concerned with the
identification and handling of user and system requirements. Aspect-Oriented Requirements
Engineering (AORE) extends the existing requirements engineering approaches to cope with the
issue of tangling and scattering resulted from crosscutting concerns. Crosscutting concerns are
considered as potential aspects and can lead to the phenomena “tyranny of the dominant
decomposition”. Requirements-level aspects are responsible for producing scattered and tangled
descriptions of requirements in the requirements document. Validation of requirements artefacts
is an essential task in software development. This task ensures that requirements are correct and
valid in terms of completeness and consistency, hence, reducing the development cost,
maintenance and establish an approximately correct estimate of effort and completion time of the
project. In this paper, we present a validation framework to validate the aspectual requirements
and the crosscutting relationship of concerns that are resulted from the requirements engineering
phase. The proposed framework comprises a high-level and low-level validation to implement on
software requirements specification (SRS). The high-level validation validates the concerns with
stakeholders, whereas the low-level validation validates the aspectual requirement by
requirements engineers and analysts using a checklist. The approach has been evaluated using
an experimental study on two AORE approaches. The approaches are viewpoint-based called
AORE with ArCaDe and lexical analysis based on Theme/Doc approach. The results obtained
from the study demonstrate that the proposed framework is an effective validation model for
AORE artefacts.
STATISTICAL ANALYSIS FOR PERFORMANCE COMPARISONijseajournal
Performance responsiveness and scalability is a make-or-break quality for software. Nearly everyone runs into performance problems at one time or another. This paper discusses about performance issues faced during Pre Examination Process Automation System (PEPAS) implemented in java technology. The challenges faced during the life cycle of the project and the mitigation actions performed. It compares 3 java technologies and shows how improvements are made through statistical analysis in response time of the application. The paper concludes with result analysis.
THE UNIFIED APPROACH FOR ORGANIZATIONAL NETWORK VULNERABILITY ASSESSMENTijseajournal
The present business network infrastructure is quickly varying with latest servers, services, connections,
and ports added often, at times day by day, and with a uncontrollably inflow of laptops, storage media and
wireless networks. With the increasing amount of vulnerabilities and exploits coupled with the recurrent
evolution of IT infrastructure, organizations at present require more numerous vulnerability assessments.
In this paper new approach the Unified process for Network vulnerability Assessments hereafter called as
a unified NVA is proposed for network vulnerability assessment derived from Unified Software
Development Process or Unified Process, it is a popular iterative and incremental software development
process framework.
Performance Evaluation using Blackboard Technique in Software ArchitectureEditor IJCATR
Validation of software systems is very useful at the primary stages of their development cycle. Evaluation of functional
requirements is supported by clear and appropriate approaches, but there is no similar strategy for evaluation of non-functional
requirements (such as performance). Whereas establishing the non-functional requirements have significant effect on success of
software systems, therefore considerable necessities are needed for evaluation of non-functional requirements. Also, if the software
performance has been specified based on performance models, may be evaluated at the primary stages of software development cycle.
Therefore, modeling and evaluation of non-functional requirements in software architecture level, that are designed at the primary
stages of software systems development cycle and prior to implementation, will be very effective.
We propose an approach for evaluate the performance of software systems, based on black board technique in software architecture
level. In this approach, at first, software architecture using blackboard technique is described by UML use case, activity and
component diagrams. then UML model is transformed to an executable model based on timed colored petri nets(TCPN)
Consequently, upon execution of an executive model and analysis of its results, non-functional requirements including performance
(such as response time) may be evaluated in software architecture level.
A FRAMEWORK FOR ASPECTUAL REQUIREMENTS VALIDATION: AN EXPERIMENTAL STUDYijseajournal
Requirements engineering is a discipline of software engineering that is concerned with the
identification and handling of user and system requirements. Aspect-Oriented Requirements
Engineering (AORE) extends the existing requirements engineering approaches to cope with the
issue of tangling and scattering resulted from crosscutting concerns. Crosscutting concerns are
considered as potential aspects and can lead to the phenomena “tyranny of the dominant
decomposition”. Requirements-level aspects are responsible for producing scattered and tangled
descriptions of requirements in the requirements document. Validation of requirements artefacts
is an essential task in software development. This task ensures that requirements are correct and
valid in terms of completeness and consistency, hence, reducing the development cost,
maintenance and establish an approximately correct estimate of effort and completion time of the
project. In this paper, we present a validation framework to validate the aspectual requirements
and the crosscutting relationship of concerns that are resulted from the requirements engineering
phase. The proposed framework comprises a high-level and low-level validation to implement on
software requirements specification (SRS). The high-level validation validates the concerns with
stakeholders, whereas the low-level validation validates the aspectual requirement by
requirements engineers and analysts using a checklist. The approach has been evaluated using
an experimental study on two AORE approaches. The approaches are viewpoint-based called
AORE with ArCaDe and lexical analysis based on Theme/Doc approach. The results obtained
from the study demonstrate that the proposed framework is an effective validation model for
AORE artefacts.
PRODUCT QUALITY EVALUATION METHOD (PQEM): TO UNDERSTAND THE EVOLUTION OF QUAL...ijseajournal
Promoting quality within the context of agile software development, it is extremely important as well as
useful to improve not only the knowledge and decision-making of project managers, product owners, and
quality assurance leaders but also to support the communication between teams. In this context, quality
needs to be visible in a synthetic and intuitive way in order to facilitate the decision of accepting or
rejecting each iteration within the software life cycle. This article introduces a novel solution called
Product Quality Evaluation Method (PQEM) which can be used to evaluate a set of quality characteristics
for each iteration within a software product life cycle. PQEM is based on the Goal-Question-Metric
approach, the standard ISO/IEC 25010, and the extension made of testing coverage in order to obtain the
quality coverage of each quality characteristic. The outcome of PQEM is a unique multidimensional value,
that represents the quality level reached by each iteration of a product, as an aggregated measure. Even
though a value it is not the regular idea of measuring quality, we believe that it can be useful to use this
value to easily understand the quality level of each iteration. An illustrative example of the PQEM method
was carried out with two iterations from a web and mobile application, within the healthcare environment.
A single measure makes it possible to observe the evolution of the level of quality reached in the evolution
of the product through the iterations.
SOFTWARE REQUIREMENT CHANGE EFFORT ESTIMATION MODEL PROTOTYPE TOOL FOR SOFTWA...ijseajournal
In software development phase software artifacts are not in consistent states such as: some of the class artifacts are fully developed some are half developed, some are major developed, some are minor developed and some are not developed yet. At this stage allowing too many software requirement changes may possibly delay in project delivery and increase development budget of the software. On the other hand rejecting too many changes may increase customer dissatisfaction. Software change effort estimation is one of the most challenging and important activity that helps software project managers in accepting or rejecting changes during software development phase. This paper extends our previous works on developing a software requirement change effort estimation model prototype tool for the software development phase. The significant achievements of the tool are demonstrated through an extensive experimental validation using several case studies. The experimental analysis shows improvement in the estimation accuracy over current change effort estimation models.
REALIZING A LOOSELY-COUPLED STUDENTS PORTAL FRAMEWORKijseajournal
Most of the currently available students' portal frameworks are tightly-coupled frameworks. A recent
research done by the authors of this paper has discussed how to distribute the concepts of the traditional
students' portal framework and came out with a distributed interoperable framework. This paper realizes
the distributed interoperable students' portal framework by developing a prototype. This prototype is based
on Service Oriented Architecture (SOA). The prototype is tested using web service testing and compatibility
testing.
JELINSKI-MORANDA SOFTWARE RELIABILITY GROWTH MODEL: A BRIEF LITERATURE AND MO...ijseajournal
Analyzing the reliability of a software can be done at various phases during the development of
engineering software. Software reliability growth models (SRGMs) assess, predict, and controlthe software
reliability based on data obtained from testing phase.This paper gives a literaturereview of the first and
wellknownJelinski and Moranda(J-M) (1972)SRGM.Also a modification to Jelinski and Morandamodel is
given, Jelinski and Moranda and Schick and Wolverton (S-W) (1978)SRGMsare two special cases of our
new suggested general SRGM. Our proposed general SRGMalong with our Survey will open doors for
much more useful researches to be done in the field of reliability modeling.
Program analysis is useful for debugging, testing and maintenance of software systems due to information
about the structure and relationship of the program’s modules . In general, program analysis is performed
either based on control flow graph or dependence graph. However, in the case of aspect-oriented
programming (AOP), control flow graph (CFG) or dependence graph (DG) are not enough to model the
properties of Aspect-oriented (AO) programs. With respect to AO programs, although AOP is good for
modular representation and crosscutting concern, suitable model for program analysis is required to
gather information on its structure for the purpose of minimizing maintenance effort. In this paper Aspect
Oriented Dependence Flow Graph (AODFG) as an intermediate representation model is proposed to
represent the structure of aspect-oriented programs. AODFG is formed by merging the CFG and DG, thus
more information about dependencies between the join points, advice, aspects and their associated
construct with the flow of control from one statement to another are gathered. We discussthe performance
of AODFG by analysing some examples of AspectJ program taken from AspectJ Development Tools
(AJDT).
Improving Consistency of UML Diagrams and Its Implementation Using Reverse En...journalBEEI
Software development deals with various changes and evolution that cannot be avoided due to the development processes which are vastly incremental and iterative. In Model Driven Engineering, inconsistency between model and its implementation has huge impact on the software development process in terms of added cost, time and effort. The later the inconsistencies are found, it could add more cost to the software project. Thus, this paper aims to describe the development of a tool that could improve the consistency between Unified Modeling Language (UML) design models and its C# implementation using reverse engineering approach. A list of consistency rules is defined to check vertical and horizontal consistencies between structural (class diagram) and behavioral (use case diagram and sequence diagram) UML diagrams against the implemented C# source code. The inconsistencies found between UML diagrams and source code are presented in a textual description and visualized in a tree view structure.
Selenium - A Trending Automation Testing Toolijtsrd
Selenium is an important testing tool for software quality assurance. In recent days number of websites are increasing rapidly and it becomes essential to test the websites against various quality factors to make sure it meets the expected quality goals. Several companies are spending a lot of bucks for the testing tool while Selenium is available completely free for the performance test. The open source tool is well known for its unlimited capabilities and unlimited reach. Selenium stands out from the crowd in this aspect. Anyone could visit the Selenium website and download the latest version and use it. It is not only an open source but also highly modifiable. Testers could make changes based upon their needs and requirements. Manav Kundra "Selenium - A Trending Automation Testing Tool" Published in International Journal of Trend in Scientific Research and Development (ijtsrd), ISSN: 2456-6470, Volume-4 | Issue-4 , June 2020, URL: https://www.ijtsrd.com/papers/ijtsrd31202.pdf Paper Url :https://www.ijtsrd.com/engineering/software-engineering/31202/selenium-%E2%80%93-a-trending-automation-testing-tool/manav-kundra
PROPERTIES OF A FEATURE IN CODE-ASSETS: AN EXPLORATORY STUDYijseajournal
Software product line engineering is a paradigm for developing a family of software products from a
repository of reusable assets rather than developing each individual product from scratch. In featureoriented software product line engineering, the common and the variable characteristics of the products
are expressed in terms of features. Using software product line engineering approach, software products
are produced en masse by means of two engineering phases: (i) Domain Engineering and, (ii) Application
Engineering. At the domain engineering phase, reusable assets are developed with variation points where
variant features may be bound for each of the diverse products. At the application engineering phase,
individual and customized products are developed from the reusable assets. Ideally, the reusable assets
should be adaptable with less effort to support additional variations (features) that were not planned
beforehand in order to increase the usage context of SPL as a result of expanding markets or when a new
usage context of software product line emerges. This paper presents an exploration research to investigate
the properties of features, in the code-asset implemented using Object-Oriented Programming Style. In the
exploration, we observed that program elements of disparate features formed unions as well as
intersections that may affect modifiability of the code-assets. The implication of this research to practice is
that an unstable product line and with the tendency of emerging variations should aim for techniques that
limit the number of intersections between program elements of different features. Similarly, the implication
of the observation to research is that there should be subsequent investigations using multiple case studies
in different software domains and programming styles to improve the understanding of the findings.
An Empirical Study of the Improved SPLD Framework using Expert Opinion TechniqueIJEACS
Due to the growing need for high-performance and low-cost software applications and the increasing competitiveness, the industry is under pressure to deliver products with low development cost, reduced delivery time and improved quality. To address these demands, researchers have proposed several development methodologies and frameworks. One of the latest methodologies is software product line (SPL) which utilizes the concepts like reusability and variability to deliver successful products with shorter time-to-market, least development and minimum maintenance cost with a high-quality product. This research paper is a validation of our proposed framework, Improved Software Product Line (ISPL), using Expert Opinion Technique. An extensive survey based on a set of questionnaires on various aspects and sub-processes of the ISPLD Framework was carried. Analysis of the empirical data concludes that ISPL shows significant improvements on several aspects of the contemporary SPL frameworks.
PRODUCT QUALITY EVALUATION METHOD (PQEM): TO UNDERSTAND THE EVOLUTION OF QUAL...ijseajournal
Promoting quality within the context of agile software development, it is extremely important as well as
useful to improve not only the knowledge and decision-making of project managers, product owners, and
quality assurance leaders but also to support the communication between teams. In this context, quality
needs to be visible in a synthetic and intuitive way in order to facilitate the decision of accepting or
rejecting each iteration within the software life cycle. This article introduces a novel solution called
Product Quality Evaluation Method (PQEM) which can be used to evaluate a set of quality characteristics
for each iteration within a software product life cycle. PQEM is based on the Goal-Question-Metric
approach, the standard ISO/IEC 25010, and the extension made of testing coverage in order to obtain the
quality coverage of each quality characteristic. The outcome of PQEM is a unique multidimensional value,
that represents the quality level reached by each iteration of a product, as an aggregated measure. Even
though a value it is not the regular idea of measuring quality, we believe that it can be useful to use this
value to easily understand the quality level of each iteration. An illustrative example of the PQEM method
was carried out with two iterations from a web and mobile application, within the healthcare environment.
A single measure makes it possible to observe the evolution of the level of quality reached in the evolution
of the product through the iterations.
SOFTWARE REQUIREMENT CHANGE EFFORT ESTIMATION MODEL PROTOTYPE TOOL FOR SOFTWA...ijseajournal
In software development phase software artifacts are not in consistent states such as: some of the class artifacts are fully developed some are half developed, some are major developed, some are minor developed and some are not developed yet. At this stage allowing too many software requirement changes may possibly delay in project delivery and increase development budget of the software. On the other hand rejecting too many changes may increase customer dissatisfaction. Software change effort estimation is one of the most challenging and important activity that helps software project managers in accepting or rejecting changes during software development phase. This paper extends our previous works on developing a software requirement change effort estimation model prototype tool for the software development phase. The significant achievements of the tool are demonstrated through an extensive experimental validation using several case studies. The experimental analysis shows improvement in the estimation accuracy over current change effort estimation models.
REALIZING A LOOSELY-COUPLED STUDENTS PORTAL FRAMEWORKijseajournal
Most of the currently available students' portal frameworks are tightly-coupled frameworks. A recent
research done by the authors of this paper has discussed how to distribute the concepts of the traditional
students' portal framework and came out with a distributed interoperable framework. This paper realizes
the distributed interoperable students' portal framework by developing a prototype. This prototype is based
on Service Oriented Architecture (SOA). The prototype is tested using web service testing and compatibility
testing.
JELINSKI-MORANDA SOFTWARE RELIABILITY GROWTH MODEL: A BRIEF LITERATURE AND MO...ijseajournal
Analyzing the reliability of a software can be done at various phases during the development of
engineering software. Software reliability growth models (SRGMs) assess, predict, and controlthe software
reliability based on data obtained from testing phase.This paper gives a literaturereview of the first and
wellknownJelinski and Moranda(J-M) (1972)SRGM.Also a modification to Jelinski and Morandamodel is
given, Jelinski and Moranda and Schick and Wolverton (S-W) (1978)SRGMsare two special cases of our
new suggested general SRGM. Our proposed general SRGMalong with our Survey will open doors for
much more useful researches to be done in the field of reliability modeling.
Program analysis is useful for debugging, testing and maintenance of software systems due to information
about the structure and relationship of the program’s modules . In general, program analysis is performed
either based on control flow graph or dependence graph. However, in the case of aspect-oriented
programming (AOP), control flow graph (CFG) or dependence graph (DG) are not enough to model the
properties of Aspect-oriented (AO) programs. With respect to AO programs, although AOP is good for
modular representation and crosscutting concern, suitable model for program analysis is required to
gather information on its structure for the purpose of minimizing maintenance effort. In this paper Aspect
Oriented Dependence Flow Graph (AODFG) as an intermediate representation model is proposed to
represent the structure of aspect-oriented programs. AODFG is formed by merging the CFG and DG, thus
more information about dependencies between the join points, advice, aspects and their associated
construct with the flow of control from one statement to another are gathered. We discussthe performance
of AODFG by analysing some examples of AspectJ program taken from AspectJ Development Tools
(AJDT).
Improving Consistency of UML Diagrams and Its Implementation Using Reverse En...journalBEEI
Software development deals with various changes and evolution that cannot be avoided due to the development processes which are vastly incremental and iterative. In Model Driven Engineering, inconsistency between model and its implementation has huge impact on the software development process in terms of added cost, time and effort. The later the inconsistencies are found, it could add more cost to the software project. Thus, this paper aims to describe the development of a tool that could improve the consistency between Unified Modeling Language (UML) design models and its C# implementation using reverse engineering approach. A list of consistency rules is defined to check vertical and horizontal consistencies between structural (class diagram) and behavioral (use case diagram and sequence diagram) UML diagrams against the implemented C# source code. The inconsistencies found between UML diagrams and source code are presented in a textual description and visualized in a tree view structure.
Selenium - A Trending Automation Testing Toolijtsrd
Selenium is an important testing tool for software quality assurance. In recent days number of websites are increasing rapidly and it becomes essential to test the websites against various quality factors to make sure it meets the expected quality goals. Several companies are spending a lot of bucks for the testing tool while Selenium is available completely free for the performance test. The open source tool is well known for its unlimited capabilities and unlimited reach. Selenium stands out from the crowd in this aspect. Anyone could visit the Selenium website and download the latest version and use it. It is not only an open source but also highly modifiable. Testers could make changes based upon their needs and requirements. Manav Kundra "Selenium - A Trending Automation Testing Tool" Published in International Journal of Trend in Scientific Research and Development (ijtsrd), ISSN: 2456-6470, Volume-4 | Issue-4 , June 2020, URL: https://www.ijtsrd.com/papers/ijtsrd31202.pdf Paper Url :https://www.ijtsrd.com/engineering/software-engineering/31202/selenium-%E2%80%93-a-trending-automation-testing-tool/manav-kundra
PROPERTIES OF A FEATURE IN CODE-ASSETS: AN EXPLORATORY STUDYijseajournal
Software product line engineering is a paradigm for developing a family of software products from a
repository of reusable assets rather than developing each individual product from scratch. In featureoriented software product line engineering, the common and the variable characteristics of the products
are expressed in terms of features. Using software product line engineering approach, software products
are produced en masse by means of two engineering phases: (i) Domain Engineering and, (ii) Application
Engineering. At the domain engineering phase, reusable assets are developed with variation points where
variant features may be bound for each of the diverse products. At the application engineering phase,
individual and customized products are developed from the reusable assets. Ideally, the reusable assets
should be adaptable with less effort to support additional variations (features) that were not planned
beforehand in order to increase the usage context of SPL as a result of expanding markets or when a new
usage context of software product line emerges. This paper presents an exploration research to investigate
the properties of features, in the code-asset implemented using Object-Oriented Programming Style. In the
exploration, we observed that program elements of disparate features formed unions as well as
intersections that may affect modifiability of the code-assets. The implication of this research to practice is
that an unstable product line and with the tendency of emerging variations should aim for techniques that
limit the number of intersections between program elements of different features. Similarly, the implication
of the observation to research is that there should be subsequent investigations using multiple case studies
in different software domains and programming styles to improve the understanding of the findings.
An Empirical Study of the Improved SPLD Framework using Expert Opinion TechniqueIJEACS
Due to the growing need for high-performance and low-cost software applications and the increasing competitiveness, the industry is under pressure to deliver products with low development cost, reduced delivery time and improved quality. To address these demands, researchers have proposed several development methodologies and frameworks. One of the latest methodologies is software product line (SPL) which utilizes the concepts like reusability and variability to deliver successful products with shorter time-to-market, least development and minimum maintenance cost with a high-quality product. This research paper is a validation of our proposed framework, Improved Software Product Line (ISPL), using Expert Opinion Technique. An extensive survey based on a set of questionnaires on various aspects and sub-processes of the ISPLD Framework was carried. Analysis of the empirical data concludes that ISPL shows significant improvements on several aspects of the contemporary SPL frameworks.
10 Insightful Quotes On Designing A Better Customer ExperienceYuan Wang
In an ever-changing landscape of one digital disruption after another, companies and organisations are looking for new ways to understand their target markets and engage them better. Increasingly they invest in user experience (UX) and customer experience design (CX) capabilities by working with a specialist UX agency or developing their own UX lab. Some UX practitioners are touting leaner and faster ways of developing customer-centric products and services, via methodologies such as guerilla research, rapid prototyping and Agile UX. Others seek innovation and fulfilment by spending more time in research, being more inclusive, and designing for social goods.
Experience is more than just an interface. It is a relationship, as well as a series of touch points between your brand and your customer. Here are our top 10 highlights and takeaways from the recent UX Australia conference to help you transform your customer experience design.
For full article, continue reading at https://yump.com.au/10-ways-supercharge-customer-experience-design/
How to Build a Dynamic Social Media PlanPost Planner
Stop guessing and wasting your time on networks and strategies that don’t work!
Join Rebekah Radice and Katie Lance to learn how to optimize your social networks, the best kept secrets for hot content, top time management tools, and much more!
Watch the replay here: bit.ly/socialmedia-plan
http://inarocket.com
Learn BEM fundamentals as fast as possible. What is BEM (Block, element, modifier), BEM syntax, how it works with a real example, etc.
Content personalisation is becoming more prevalent. A site, it's content and/or it's products, change dynamically according to the specific needs of the user. SEO needs to ensure we do not fall behind of this trend.
Lightning Talk #9: How UX and Data Storytelling Can Shape Policy by Mika Aldabaux singapore
How can we take UX and Data Storytelling out of the tech context and use them to change the way government behaves?
Showcasing the truth is the highest goal of data storytelling. Because the design of a chart can affect the interpretation of data in a major way, one must wield visual tools with care and deliberation. Using quantitative facts to evoke an emotional response is best achieved with the combination of UX and data storytelling.
Succession “Losers”: What Happens to Executives Passed Over for the CEO Job?
By David F. Larcker, Stephen A. Miles, and Brian Tayan
Stanford Closer Look Series
Overview:
Shareholders pay considerable attention to the choice of executive selected as the new CEO whenever a change in leadership takes place. However, without an inside look at the leading candidates to assume the CEO role, it is difficult for shareholders to tell whether the board has made the correct choice. In this Closer Look, we examine CEO succession events among the largest 100 companies over a ten-year period to determine what happens to the executives who were not selected (i.e., the “succession losers”) and how they perform relative to those who were selected (the “succession winners”).
We ask:
• Are the executives selected for the CEO role really better than those passed over?
• What are the implications for understanding the labor market for executive talent?
• Are differences in performance due to operating conditions or quality of available talent?
• Are boards better at identifying CEO talent than other research generally suggests?
A novel statistical cost model and an algorithm for efficient application off...Finalyearprojects Toall
To get IEEE 2015-2017 Project for above title in .Net or Java
mail to finalyearprojects2all@gmail.com or contact +91 8870791415
IEEE 2015-2016 Project Videos: https://www.youtube.com/channel/UCyK6peTIU3wPIJxXD0MbNvA
Using Model-Driven Engineering for Decision Support Systems Modelling, Implem...CSCJournals
Following the principle of everything is object, software development engineering has moved towards the principle of everything is model, through Model Driven Engineering (MDE). Its implementation is based on models and their successive transformations, which allow starting from the requirements specification to the code’s implementation. This engineering is used in the development of information systems, including Decision-Support Systems (DSS). Here we use MDE to propose an DSS development approach, using the Multidimensional Canonical Partitioning (MCP) design approach and a design pattern. We also use model’s transformation in order to obtain not only implementation codes, but also data warehouse feeds.
A Comparative Study of Forward and Reverse Engineeringijsrd.com
With the software development at its boom compared to 20 years in the past, software developed in the past may or may not have a well-supported documentation during the software evolution. This may increase the specification gap between the document and the legacy code to make further evolutions and updates. Understanding the legacy code of the underlying decisions made during development is the prime motto, which is very well supported by Reverse Engineering. In this paper, we compare the Transformational Forward engineering, where a stepwise abstraction is obtained with the Transformational Reverse Methodology. While the forward transformation process produces overlap of the decisions, performance is affected. Hence, the use of transformational method of Reverse Engineering which is a backwards Forward Engineering process is suitable. Besides the design recognition obtained is a domain knowledge which can be used in future by the forward engineers.
Reengineering framework for open source software using decision tree approachIJECEIAES
A Software engineering is an approach to software development. Once software gets developed and delivered, it needs maintenance. Changes in software incur due to new requirements of the end-user, identification of bug in software or failure to achieve system objective. It has been observed that successive maintenance in the developed software reduces software quality and degrades the performance of software system. Reengineering is an approach of retaining the software quality and improving maintainability of the software system. But the question arises “when to reengineer the software”. The paper proposed a framework for software reengineering process using decision tree approach which helps decision makers to decide whether to maintain or reengineer the software systems.
RESILIENT INTERFACE DESIGN FOR SAFETY-CRITICAL EMBEDDED AUTOMOTIVE SOFTWAREcsandit
The replacement of the former, purely mechanical, functionality with mechatronics-based solutions, the introduction of new propulsion technologies, and the connection of cars to their environment are just a few reasons for the continuously increasing electrical and/or electronic
system (E/E system) complexity in modern passenger cars. Smart methodologies and techniques have been introduced in system development to cope with these new challenges. A topic that is often neglected is the definition of the interface between the hardware and software subsystems.
However, during the development of safety-critical E/E systems, according to the automotive
functional safety standard ISO 26262, an unambiguous definition of the hardware-software interface (HSI) has become vital. This paper presents a domain-specific modelling approach for mechatronic systems with an integrated hardware-software interface definition feature. The
newly developed model-based domain-specific language is tailored to the needs of mechatronic system engineers and supports the system’s architectural design including the interface definition, with a special focus on safety-criticality.
RESILIENT INTERFACE DESIGN FOR SAFETY-CRITICAL EMBEDDED AUTOMOTIVE SOFTWAREcscpconf
The replacement of the former, purely mechanical, functionality with mechatronics-based solutions, the introduction of new propulsion technologies, and the connection of cars to their environment are just a few reasons for the continuously increasing electrical and/or electronic system (E/E system) complexity in modern passenger cars. Smart methodologies and techniques have been introduced in system development to cope with these new challenges. A topic that is often neglected is the definition of the interface between the hardware and software subsystems. However, during the development of safety-critical E/E systems, according to the automotive functional safety standard ISO 26262, an unambiguous definition of the hardware-software interface (HSI) has become vital. This paper presents a domain-specific modelling approach for mechatronic systems with an integrated hardware-software interface definition feature. The newly developed model-based domain-specific language is tailored to the needs of mechatronic system engineers and supports the system’s architectural design including the interface definition, with a special focus on safety-criticality
PHP modernization approach generating KDM models from PHP legacy codejournalBEEI
With the rise of new web technologies such as web 2.0, Jquery, Bootstrap. Modernizing legacy web systems to benefit from the advantages of the new technologies is more and more relevant. The migration of a system from an environment to another is a time and effort consuming process, it involves a complete rewrite of the application adapted to the target platform. To realize this migration in an automated and standardized way, many approaches have tried to define standardized engineering processes. Architecture Driven Modernization (ADM) defines an approach to standardize and automate the reengineering process. We defined an ADM approach to represent PHP web applications in the highest level of abstraction models. To do this, we have used software artifacts as a entry point . This paper describes the extraction process, which permits discovering and understanding of the legacy system. And generate models to represent the system in an abstract way.
An architectural model is a rich and rigorous diagram created using available standards, in which the primary concern is to illustrate a specific set of tradeoffs inherent in the structure and design of a system or ecosystem.
Model driven process for real time embeddedcaijjournal
Embedded systems shape our world nowadays. It’s almost impossible to imagine our day to day life without
it. Examples can include cell phones, home appliances, energy generators, satellites, automotive
components …etc. it is even far more complex if there are real-time and interface constraints.
Developing real-time embedded systems is significantly challenging to developers. Results need not be only
correct, but also in a timely manner. New software development approaches are needed due to the
complexity of functional and non-functional requirements of embedded systems.
Due to the complex context of embedded systems, defects can cause life threatening situations. Delays can
create huge costs, and insufficient productivity can impact the entire industry. The rapid evolution of
software engineering technologies will be a key factor in the successful future development of even more
complex embedded systems.
Software development is shifting from manual programming, to model-driven engineering (MDE). One of
the most important challenges is to manage the increasing complexity of embedded software development,
while maintaining the product’s quality, reducing time to market, and reducing development cost.
MDE is a promising approach that emerged lately. Instead of directly coding the software using
programming languages, developers model software systems using expressive, graphical notations, which
provide a higher abstraction level than programming languages. This is called Model Based Development
(MBD).
Model Based Development if accompanied by Model Based Validation (MBV), will help identify problems
early thus reduce rework cost. Applying tests based on the designed models not only enable early detection
of defects, but also continuous quality assurance. Testing can start in the first iteration of the development
process.
As a result of the model based approach, and in addition to the major advantage of early defects detection,
several time consuming tasks within the classical software development life cycle will be excluded. For
embedded systems development, it’s really important to follow a more time efficient approach.
HW/SW Partitioning Approach on Reconfigurable Multimedia System on ChipCSCJournals
Due to the complexity and the high performance requirement of multimedia applications, the design of embedded systems is the subject of different types of design constraints such as execution time, time to market, energy consumption, etc. Some approaches of joint software/hardware design (Co-design) were proposed in order to help the designer to seek an adequacy between applications and architecture that satisfies the different design constraints. This paper presents a new methodology for hardware/software partitioning on reconfigurable multimedia system on chip, based on dynamic and static steps. The first one uses the dynamic profiling and the second one uses the design trotter tools. The validation of our approach is made through 3D image synthesis.
A FRAMEWORK STUDIO FOR COMPONENT REUSABILITYcscpconf
The deployment of a software product requires considerable amount of time and effort. In order
to increase the productivity of the software products, reusability strategies were proposed in the
literature. However effective reuse is still a challenging issue. This paper presents a framework
studio for effective components reusability which provides the selection of components from framework studio and generation of source code based on stakeholders needs. The framework studio is implemented using swings which are integrated onto the Net Beans IDE which help in faster generation of the source code.
Similar to Integrating profiling into mde compilers (20)
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
Let's dive deeper into the world of ODC! Ricardo Alves (OutSystems) will join us to tell all about the new Data Fabric. After that, Sezen de Bruijn (OutSystems) will get into the details on how to best design a sturdy architecture within ODC.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
"Impact of front-end architecture on development cost", Viktor TurskyiFwdays
I have heard many times that architecture is not important for the front-end. Also, many times I have seen how developers implement features on the front-end just following the standard rules for a framework and think that this is enough to successfully launch the project, and then the project fails. How to prevent this and what approach to choose? I have launched dozens of complex projects and during the talk we will analyze which approaches have worked for me and which have not.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
FIDO Alliance Osaka Seminar: The WebAuthn API and Discoverable Credentials.pdf
Integrating profiling into mde compilers
1. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
DOI : 10.5121/ijsea.2014.5401 1
INTEGRATING PROFILING INTO MDE COMPILERS
Vincent Aranega2
, A. Wendell O. Rodrigues1
, Anne Etien2
, Fréderic Guyomarch2
,
and Jean-Luc Dekeyser2
1
PPGCC – Instituto Federal do Ceará, Fortaleza, Brazil
2
INRIA Nord Europe, Lille, France
ABSTRACT
Scientific computation requires more and more performance in its algorithms. New massively parallel
architectures suit well to these algorithms. They are known for offering high performance and power
efficiency. Unfortunately, as parallel programming for these architectures requires a complex distribution
of tasks and data, developers find difficult to implement their applications effectively. Although approaches
based on source-to-source intends to provide a low learning curve for parallel programming and take
advantage of architecture features to create optimized applications, programming remains difficult for
neophytes. This work aims at improving performance by returning to the high-level models, specific
execution data from a profiling tool enhanced by smart advices computed by an analysis engine. In order to
keep the link between execution and model, the process is based on a traceability mechanism. Once the
model is automatically annotated, it can be re-factored aiming better performances on the re-generated
code. Hence, this work allows keeping coherence between model and code without forgetting to harness the
power of parallel architectures. To illustrate and clarify key points of this approach, we provide an
experimental example in GPUs context. The example uses a transformation chain from UML-MARTE
models to OpenCL code.
KEYWORDS
Profiling – MDE – Traceability – Performance Analysis
1. INTRODUCTION
Advanced engineering and scientific communities have used parallel programming to solve their
large-scale complex problems for a long time. Despite the high level knowledge of the developers
belonging to these communities, they find hard to effectively implement their applications on
parallel systems. Some intrinsic characteristics of parallel programming contribute to this
difficulty, e.g., race conditions, memory access bottleneck, granularity decision, scheduling
policy or thread safety. In order to facilitate programming parallel applications, developers have
specified several interesting programming approaches.
To increase the application development, software researchers have been creating abstraction
layers that help themselves to program in terms of their design intent rather than the underlying
architectures, (e.g., CPU, memory, network devices). Approaches based on Model Driven
Engineering (MDE), in particular MDE compilers, have frequently been used as a solution to
implement these abstraction layers and thus accelerate system development.
MDE compilers take high-level models as input and a specific source code language is produced
as output. Dealing with high-level models gives to the model designer a twofold advantages: on
2. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
2
the one hand it increases re-usability and on the other hand it hides specific low-level details of
code generation from the designed model. In this context, the system is directly generated from
the high-level models.
However, the generated system can produce low performance issues due to a poor model design,
even if optimization stages are proposed or implemented by the MDE compiler. In these cases,
fine-tuning the generated code to improve the performances is a real need.
In an MDE approach, fixing the system implies applying modifications on one of the two
artifacts: the designed models or the system source code. Directly modifying the generated source
code is a difficult task for the model designer that does not know details about the target platform.
Actually, the designer does not necessarily have the knowledge to efficiently modify the code.
Moreover, the designed models lose the synchronization with the source code. A good solution to
keep the coherence between the designed models and the generated source code is to regenerate
code from the model correctly modified. Thus, changes aiming to achieve better performance
must be made directly in the designed input models.
However, two issues make this method difficult to initiate as solution. Firstly, when a
performance issue is observed, it is hard to figure out which parts of the models are responsible
for this issue [15]. Thus, we have to keep a link between the models, the performance
observations and the runtime results. Secondly, even if problems in the models are found,
efficiently modifying it is not an easy task. Indeed, to provide better and more efficient changes in
the models, the improvement must often take into account details of the target architecture,
usually unknown and hidden to the designer.
Among the different techniques proposed to assist the designer during the performance
improvement phase, two categories of tools can be found. The first one deals with static
estimation computed in the model, whereas the second one, called profiling, deals with dynamic
information. Our contribution focuses on profiling category because of its ability to gather details
from a real execution environment. Hence, the recovered information comes directly from the
system execution rather than from an estimation computed from the input high-level models.
In this paper, we present a framework to introduce performance optimization in MDE compilers.
The main goal in this work is to provide a high-level profiling environment in a model design
context where performance feedbacks are directly provided in the input models. With these visual
feedbacks, model designers can easily identify the model parts producing poor performances. The
performance information is recovered from dedicated profiling tools returning important
measures as the running time or memories access time. This framework is based on model
traceability to automatically return details and performance measures obtained during the system
execution directly in the designed models.
In addition to the profiling information, the framework deals with dedicated advices, assisting the
model designer quicly fine-tuning their models to achieve better results. These smart advices are
computed by using the measured performances and specification details of the runtime plateform
specification. Once the models modified according to the proposed approach, the system is then
regenerated keeping coherence between the models and the code.
To validate our framework, we present in this paper two case studies in a MDE compiler towards
GPU architecture. These cases studies take place in the Gaspard2 [7] environment: an MDE
framework for parallel-embedded systems. Gaspard2 proposes, among others, an MDE compiler
to several programming languages. The compiler takes UML models profiled with the MARTE
3. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
3
standard profile [13] as input model and generates system for few target platforms to reach
simulation and validation purposes. Among the different target languages, Gaspard2 includes an
OpenCL branch introduced in [16][17]. Using such a framework, the designer can focus on the
general system architecture without worrying about the Open Computing Language (OpenCL) [9]
implementation details.
The paper is structured as follows: in section 2, we discuss about the major works of the domain.
In section 3, we identify the different challenges we deal with in this paper. In section 4, we
present how the profiling information is linked to the high-levels models. Then, in section 5, we
illustrate this information feedback on an example in. In section 6, we present how the dedicated
advices are computed before illustrating this advice computation on an example in section 7.
Finally, we conclude and discuss about further works in section 8.
2. RELATED WORK
The analysis of software performance is part of the Software Performance Engineering (SPE)
[19]. The SPE process uses multiple performance assessment tools depending on the state of the
software and the amount of performance data available. SPE is a relatively mature approach and
normally is associated to the prediction of the performance of software architectures during early
design stages.
Several performance-modeling approaches have been proposed in the literature, including
simulation-based or model-based approaches, often based on UML. Some examples of works,
which have been developed in this research field, are enumerated below.
1. Model-Driven SPE (MDSPE) is proposed in [20] and deals with building annotated UML
models for performance, which can be used for the performance predictions of software
systems. MDSPE consists in deriving the performance models from the UML
specifications, annotated according to the OMG profile for Schedulability, Performance,
and Time (SPT) [12]. Many steps: Performance Annotation and Performance Analysis
compose this approach. The first one deals with encapsulation of performance
characteristics of the hardware infrastructure, as well as Quality of Service requirements
of specific functions. The second one is implemented by a performance analyzer, which
computes the performance metrics, which thereby predicts the software performance.
2. A simulation-based software performance modeling approach for software architectures
specified with UML is proposed in [2]. Similarly to MDSPE, this approach is based on
the OMG profile SPT [12]. Performance parameters are introduced in the specification
model with an annotation. However, unlike the previous work, performance results
estimated by the execution of the simula- tion model are eventually inserted into the
original UML diagrams as tagged values, so providing a feedback to the software
designer. The proposed method- ology has been implemented into a prototype tool called
Software Architectures Performance Simulator (SAPS) [2].
3. The ArgoSPE approach, proposed in [8], is a tool for the performance evaluation of
software systems in the first stages of the development process. From the designer’s
viewpoint, ArgoSPE is driven by a set of “performance queries” that they can execute to
get the quantitative analysis of the modeled system. For ArgoSPE, the performance query
is a procedure whereby the UML model is analyzed to automatically obtain a predefined
performance index. The steps carried out in this procedure are hidden to the designer.
Each performance query is related to a UML diagram where it is interpreted, but it is
computed in a petri network model automatically obtained by ArgoSPE.
4. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
4
4. An interesting approach aiming at model refactoring is depicted in [10]. This approach
relies on optimization of parallel and sequential tasks on FPGA accelerators. In this case,
before generating the VHDL code, the application at Register Transfer Level (RTL) is
analyzed by an optimization system, which exploits the allocation of FPGA resources.
Then, the input model receives changes according to the optimization process results.
Further, there are several other research works that deal with SPE and UML but they are less co-
related and we are not going into extended details. CB-SPE [3] reshapes UML performance
profiles into component based principles. Model-Driven Performance Engineering (MDPE) [5]
describes a model transformation chain that integrates multiparadigm decision support into
multiple Process Modeling Tools. An extension [6] added to this work uses traceability and
simulation engines in order to provide feedback to model designers. And in [15] is proposed a
graph-grammar based method for transforming automatically a UML model annotated with
performance information into a Layered Queueing Network (LQN) performance model [21].
As stated in the introduction, we base our work on the MARTE profile. It provides special
concepts for performance analysis: Performance Analysis Modeling (PAM). This allows the
model designer to define execution platform specification in the input models. However, as in
UML SPT, the platform specification is modeled in the input model and assumes infrastructure
knowledge from the model designer. Moreover, according to the specification, the performance
analysis should be obtained from static estimations that may be very different from performances
measured at runtime.
In short, all these earlier works lack the profiling feedback and possible directions aiming better
performances in a real execution environment. Besides, they do not take into account small
differences in features of the target platform and their relation with application behavior.
Moreover, they impose to annotate the high level models, requiring a double expertise from the
model designers. Indeed, they have to correctly design the models and correctly annotate them
with runtime plateform specification. Our work does not require early annotations and relies on
real execution environment aiming to make possible fine-tuning applications at design time.
3. PROFILING TOOLS INTO MDE COMPILERS: CHALLENGES
From the designed application point of view, these annotations are not required to generate the
software. Moreover the runtime plateform specifications are a simple knowledge attached to the
hardware, which could be managed out of the designed model. This paper addresses the challenge
to take benefit from information about performance of the generated software provided by an
existing profiling tool.
The general process is sketched in Figure 1a. It is made of three main parts (noted A, B and C)
that represent a classic profiling integration in a software life cycle: part A represents the
software compilation, part B corresponds to the software execution, and part C sketches the
profiling information inclusion.
For an MDE approach, the flow is detailed as follow. Once we have the high-level models, the
MDE compiler generates the software (step 1, named transformations chain in Figure 1a). The
software is then compiled and executed (step 2 and 3). Thanks to a profiling tool, several
performance measures are gathered (step 4) and are brought back in the initial high-level models
(step 5). Although our methodology does not impose a rigid workflow, our approach relies on two
major activities: first we run the code exactly as it is generated from the original input model,
5. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
5
then the application designer analyzes the runtime behavior based on profiling feedback
annotated on the input model; second, the designer, taking into account the provided information,
modifies the model aiming to obtain better results. Once the model is modified, the code is again
generated and then executed in order to verify the result of theses changes. This simple flow
addresses many challenges linked to the transformation from abstraction layers to others.
Indeed, the obtained profiling information gives execution details, which are only linked to the
generated source code lines (e.g, a time measure is relative to a function or a variable in the
source code). This profiling information must be linked to input models to be really useful for the
model designer. How to propagate profiling information to the design model is, therefore, an
issue, which must be resolved. As first answers to this issue, the model transformation traceability
is interesting because it allows keeping links between the models during transformations steps.
Dealing with the profiling information raises another issue. The software performances gathered
by the profiling tool give profiling information about the source code and could be far from the
designed model (e.g, about memory consumption or time measure which can be comprehensible
only on source code). They might be useless and hard to analyze to adequately modify the
designed model. In this context, handling the runtime plateform details, as memory size or the
number of thread allowed can be useful. Indeed, they could be analysed with the profiling
information in order to give a clue on the way to modify the software. To ease the analysis, the
profiling information conjointly used with an automatic analysis could give more adequate
information to the model designer.
Figure 1a. Towards Integrating Profiling and
MDE Compilers
Figure 1b. Approach Overview
To propose a profiling solution for MDE compilers the two following main issues must be solved:
• how to connect the profiling information to the high level models
• how to bring the profiling information intelligible for the high level models
In order to introduce solution for these issues, we propose in this paper an adaptable framework
helping MDE compiler developer to add a profiling capability to their compilers. Beyond the
issues we raised in this section, the framework relies on the following statements regarding the
MDE compiler (transformation chain):
6. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
6
• the transformation chain must have a model transformation traceability support
• a profiling tool must exist for the target language
On the one hand, the model traceability support is a first answer to the “how to connect” issue.
For a given transformation chain (MDE compiler), it helps to link elements from the input of the
chain to their respective generated elements at the end of the chain and vice versa (we discuss
about the model transformation traceability in section 4.3). On the other hand, using an existing
profiling tool allows to take benefits from expert development and it supposes that the obtained
profiling results are trustworthy.
4. FROM EXECUTIONS TO MODELS
In this section, we address the first challenge we previously discuss:
• how to connect the profiling tool information to the high level models
Our approach for the profiling information feedback is sketched in Figure 1b. The part A (code
generation) is similar to the one presented in Figure 1a except that traceability is introduced. The
presented profiling life cycle follows a classic structure:
1. the software is generated from the high-level models (step 1) and the trace models are
produced
2. the software is executed, producing profiling logs (steps 2 to 4)
3. the produced logs are returned in the input models (steps 5 to 6).
Currently, in works available through the literature, only the first part of the process is automatic
(step 1). The second part (steps 2 to 4) producing the logs highly depends on the used tools. The
third part where logs are analysed and connected to the input elements that should be modified
remains a manual and complex process. In this paper, we focus on this step of the process (steps 5
to 6 in Figure 1b) by automating it.
In order to automate the profiling information feedback, our process uses: the model-to-model
traceability (Trace Model).
In this section, we present how the traceability is managed in the compilation chain and the
required modifications on the model compilation chain. Then, we present how the profiling
information are reported into the high-level models.
4.1. Managing The Whole Chain Traceability and Avoiding Model-to-Text
Traceability
In order to keep the links between the input models and the software execution, trace models are
produced all along the compilation chain, except for the model-to-text transformation. The
translation from model to text implies keeping information on text blocks and words [14]. The
granularity for this kind of trace made its management and maintainability difficult. In our case,
the code has to be studied only in term of the abstract concepts from the models, and not in terms
of blocks and words. To be coherent with this idea, in this paper, the model-to-text traceability
has been avoided.
To bypass the model-to-text trace, the code generation deals with unique identifiers (UIDs)
associated to each element in the last model of the transformation chain. The profiling logs
produced by the software execution refer to the UID of the analysed element. Thus, the Profiling
7. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
7
Logs can be rebound to the model elements. Concretely, in order to generate the UIDs, we use the
Eclipse Modelling Framework (EMF) feature called Universal Unique IDentifier (UUID) and,
consequently, we modify the compilation chain. A new transformation only adding the UID is
inserted as last step of the model-to-model transformation chain, just before the code generation.
4.2. Profiling Logs Parsing
According to the used Software Development Kit (SDK) and profiling tools, these profiling logs
are generated with a dedicated format. This format is parsed using a shell-script that builds a
profiling model conform to the metamodel presented in Figure 2. This metamodel is generic
enough to produce models gather information that can be found in the profiling logs.
The metamodel root: ProfilingModel gathers several LogEntries, which represent the profiling
entries from the logs. In addition, ProfilingModel specifies the running hardware model (e.g.
Tesla T10 or G80 in GPU context) with the archiModel at tribute. Each LogEntry contains
several Parameter elements owning a kind and a data representing: the information type (e.g.,
occupancy, time or memory consumption), and its value. In order to keep the link between the
profiling information and the transformation chain, each LogEntry keeps the introduced UID from
the logs. In addition, a timeStamp attribute is added to the LogEntry in order to keep the logs
sequence.
Figure 2. Profiling metamodel
4.3. Backtracking Profiling Information in the Input Model
We have argued in section 3 that a link must be kept from the profiling logs to the designed
model. With the UIDs use, we full in the gap between execution logs and models. Now, in order
to report the profiling information back in the designed models, we must exploit the model
transformations traceability links.
Model transformation traceability keeps links between the elements consumed and produced
during a transformation execution. All of these links, produced for one transformation, are
gathered in a trace model. However, MDE compilers usually deal with transformations chains
implying multiple transformation and thus multiple trace models. To maintain the traceability
links on a whole transformation chain, we deal here with our own traceability mechanism [1],
based on two specific trace metamodels.
The first one, the local trace metamodel, is used to keep the traceability link for a single
transformation, whereas the second one, the global trace metamodel, is used to maintain the local
trace order in a transformation chain. These two metamodels enable the identification of the high-
level model elements that have lead to the creation of elements in the model used for the code
generation.
8. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
8
The profiling information feedback is performed in two steps. First, each LogEntry (Figure 2) is
linked to the elements it refers to in the model used for the code generation. Indeed, the UIDs
contained in the LogEntries refer to elements in the last model before the code generation. Then,
once the element referred by the UIDs are found,
the model transformation traces are backward navigated in order to recover the input elements
producing the profiling information. During the backward navigation, two cases can occur, the
retrieved elements are reduced to one or several elements.
If only one element is found, the advice is simply reported on it. However, if multiple elements
are found, a different strategy must be applied because reporting the advice on all retrieved
elements can create confusion. To solve this issue, the expert system can be configured to specify
some element types of the input metamodel for each profiling information. From this way, only
the input elements of the specified types are kept. Finally, the profiling information is connected
to these elements in the input models. In the following section, we illustrate our report mechanism
on a case study.
5. EXAMPLE AND BENCHMARKS
5.1. UML/MARTE to OpenCL Chain
The Gaspard2 environement [7] is used for SoC co-design and contains many MDE compiler
chains. Among them, a branch of Gaspard2 allows to generate OpenCL [9] code from an
application model specified in UML-MARTE. It aims to provide resources for application
development to non-specialists in parallel programming. Thus, physicists, for instance, can
develop applications with performances comparable to those manually developed by experienced
programmers. Table 1 presents the set of model transformations that compose the chain towards
OpenCL. The whole process is detailed in [18].
Table 1. OpenCL Transformation Chain
#Transformation Description
1: UML to MARTE Metamodel This transformation adapts a model conforming to UML to a model
conforming to the MARTE metamodel. Thus, remaining
transformations do not need to deal with all unnecessary extra
complexity of UML.
2: Instances Identification This transformation adds instances of ports for each part within a
component. In order to easily identify local variable.
3: Tiler Processing This module transforms every tiler connector [4] to tiler tasks.
4: Local Graph Generation
5: Global Graph Generation
6: Static Scheduling Policy
These transformations are responsible for the definition of task
graphs and the application of a simple scheduling policy.
7: Memory Allocation It regards to memory handling, variable definition, and data
communication.
8: Hybrid Conception It summarizes all explicitly modeled or implicitly defined elements
by earlier transformations into a single structure.
9: Code Generation This model-to-text transformation transforms the earlier analyzed
elements directly to source code according to the OpenCL syntax.
5.2. UML/MARTE to OpenCL: Prerequisites and Adaptation
Some adaptations are required before applying our apporach in order to satisfy the prerequisites.
As shown in the previous section, to introduce our approach in an existing transformations chain,
some prerequisites and adjustments are necessary. The traceability mechanism is already
9. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
9
supported in Gaspard2; the OpenCL transformation chain has to be modified to manage UIDs
and a useful profiling tool must be used.
5.2.1. Profiling Tool for OpenCL
For OpenCL code profiling, we use a tool proposed by NVidia: ComputeVisualProfiler [11]. This
tool performes several measures during the application execution on the GPU and reports them in
a classical text file (i.e, profiling log). This profiling tool uses the function names as pointer for
the developers to help them to figure out on which part of the code the profiling information are
relative to. From this profiling log, the profiling tool can produce a graphical view of the obtained
profiling information. The generated logs also contain information about the execution platform,
such as the GPU model used.
5.2.2. Adding UIDs in the Transformation Chain
A model transformation is added to the OpenCL transformation chain to introduce the UIDs in
the generated source code. This transformation is inserted before the code generation (the 9th
transformation in Table 1). As the profiling tool uses the function names as pointers and as they
are generated from the element name attribute, the added transformation concatenates, for each
element, the element UID to the element name attribute. By this way, the elements UIDs are
present in the profiling logs when the generated software is executed.
5.3. Case: Conjugate Gradient Solver
The case study we propose in this paper is a complete example which presents an application
design, code generation and the profiling feedback. The example is based on the Conjugate
Gradient (CG) algorithm.
The CG is a common numerical algoritm used to solve large linear systems. Here, this method is
the masterpiece of a generated application, part of an industrial simulation tool and its input data
comes from a mesh representing an electrical machine: in our example the machine is an
automotive alternator developed by VALEO1
. Alternators are AC electrical generators and
usually the word refers to small rotating machines driven by automotive.
We have applied the approach on this real industrial example. And this produces a linear system
whose matrix A has n = 775,689 and nnz = 12,502,443. Benchmarks for this example gives
speedup of 9x with relation to standard Fortran version on CPU. We had 10,000 iterations in
about 2300 seconds on CPU against 250 seconds on GPU. This is a good result that shows the
potential increase in speedup according to complexity of the problem. From this application, two
operations are analyzed in order to apply our approach. The dot product that is depicted in
Subsection 5.4, and the DAXPY that is used as a case study in Section 7.
For all the tests, the configuration environment was as follows:
• CPU AMD Opteron 8-core @2.4GHz and 64GB RAM;
• GPU NVidia S1070 4 devices Tesla T10 (4GB RAM each) - Compute Capability 1.3;
• Linux, GCC 4.1.2, OpenCL 1.0.
5.4. Task Distribution of the Dot Product
1
www.valeo.fr
10. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
10
Dot product operations consist in two parts: a scalar multiplication, element by element and then
the sum of all these products. This last step is called a reduction and can be performed partially in
parallel, but it always come to a point where the last addition is performed sequentially. This very
last step is usually done on the CPU. Then a model designer must decide when to remove the last
reduction from GPU (see Figure 3). In fact, once the synchronization of work-items in GPUs is
made at work-group level, the final reduction r2 must be either ended on the CPU, either on the
GPU but this last solution needs to relaunch a new kernel. Because of this overload, the final
parallel reduction runs on the host side. For instance, in Figure 3, we perform the dot product on
vectors of 2516892 elements. The host launches 492 work-groups containing 512 work-items.
Each work-item performs the product between two corresponding elements. A special elementary
task (r:Reduc) is deployed by a special IP that does a parallel reduction and selects only the first
iteration to write out the reduction result. At the end, 492 results are produced. The best
"candidate" solution is to perform the final reduction on the host side (CPU). In such a scenario, it
is necessary to take into account the size of vectors. Indeed, for huge vectors the number of work-
items per work-group can exceed the hardware limits. We do not provide any automatic proposal
for this situation. However, the profiling feedback can help the designer to identify either this is
really the best solution or, otherwise, to allocate the final reduction onto the GPU. Information
about execution times can provide the answer.
5.4.1. From Logs to Annotated Model
Our approach allows annotating directly on the high-level model information about runtime
operations. The proposed methodology extracts profiling results, transforms them into model
elements, and, by using the UID (discussed in 5.2.2), it is able to report them as a comment onto
the allocate element. This information allows the model designer to take a decision for the more
suitable allocation choice.
Figure 3. Profiling Results Extract in CSV Format
The profiling environment creates a log file in CSV format having some dynamic measured data
(as seen in Listing 1). The file header (line 1 to 4) contains data about the target platform. The
code run in a Tesla T10 GPU in this case (line 2). The remaining list consists in description of
fields and log entries. The description of fields (line 5) indicates in which order they will appear
in a log entry. For instance, in Listing 1, a log entry begins with the timestamp field. The second
field that can be retrieved in an entry is gpustarttimestamp, then method, and so on. For each
entry, the method field indicates the GPU kernel call (line 8), except for the ones with the method
field set to memcpyHtoDasync and memcpyDtoHasync (corresponding to memory copies, lines 6,
7 and 9).
2
This number comes from industrial simulations.
11. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
11
This profiling file is analyzed by a shell-script parser, which converts it to XMI format that
conforms to the profiling metamodel depicted in Figure 2. The model (Figure 4) created from the
CSV log file gathers exactly the same information. Except the timestamp field and the UID
contained in the method field that becomes attributes of the LogEntry, all the other fields (e.g.
gputime, cputime or ndrangesizex) are transformed into Parameters with the value of the log
entry. Listing 1 (highlighted elements) and Figure 4 present the UID parameter with value
_sb9LkTquEeGg4rUXqAwjQA for the kernel call with timestamp equals 225819.000.
The profiling information feedback algorithm uses the UID retrieved from the profiling logs.
From the Listing 1 and Figure 4, the highlighted UID corresponds to an element in the model
produced by the “add UID” model transformation; the element with this UID is found in the
model before the code generation.
Table 2 – Element Set Gathered by the Backward Naviguation
Element found High-level Elements
PPdotProd_KRN : Kernel
Multiply : Class
m : Property
frommtogp : Abstraction
Table 2 gathers the found element3
and the elements retrieved from the backward trace
naviguation from it. The profiling information is relative to the PPdotProd_KRN: Kernel element,
which has been generated from the high-level models by 3 elements. The profiling information
must thus be linked to the 3 retrieved elements. However, we decided to handle the time relative
information differently from the others. Instead of attaching the information to each retrieved
elements, we decided to attach the information only to Abstraction type elements. Indeed, time
relative measures strongly depends on the way the tasks are placed on the hardware, thus the
Abstraction link is the better candidate to report the information on. So, in our example, the time
relative information is attached to the frommtogp: Abstraction element (Abstraction stereotyped
with allocate in Figure 5). The other information coming from the profiling log has been removed
for reading purposes.
Figure 4. Profiling Results Model
3
In this table, we have removed the elements UIDs for readability reasons.
12. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
12
5.4.1. From Logs to Annotated Model
Figure 6 shows us the valuable difference with respect to the execution time on the CPU. The
operation takes 3.5ms on the CPU while it takes 0.72ms on the GPU. Such a result makes the
model designer deciding to switch the allocation of the last reduction task from the CPU to the
GPU. Despite its visual representation, this indication is even more relevant when the model
designer has runtime details and can change only a single arrow to choose another processor to
run the operation. All the complex lines of OpenCL code about data transfers, kernel launches,
and so on, are avoided. Thus, the new generated code is ready, useful, and achieves more
performance than the initial one.
In the previous sections, we show how information that directly came from the profiling tool are
brought to the high-level models. This information feedback from the software execution defeats
the first challenge exposed in section 3. In this case, the added comment is comprehensible in the
inputmodel, but it is not always the case.
Figure 5. Summary of the UML-MARTE Model of Dot Product - Final Reduction on CPU
In the previous sections, we show how information that directly came from the profiling tool are
brought to the high-level models. This information feedback from the software execution defeats
the first challenge exposed in section 3. In this case, the added comment is comprehensible in the
input model, but it is not always the case.
Figure 6. Summary of the UML-MARTE Model of Dot Product - Final Reduction on GPU
13. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
13
6. HELPFUL ADVICES FOR MODEL DESIGNERS
In this section, we address the second challenge we previously discussed:
• how to bring the profiling information comprehensible for the high level models
Indeed, as we explained in section 3, the profiling information can be close to the generated code
and, therefore, some profiling information is potentially not useful or hard to interpret for the
models designers. Thus, the profiling information should be analysed to give a more intelligible
execution feedback. Figure 7 illustrates our approach with the profiling log analysis. Only the
part C changes, by integrating an expert system, represented by the α-box. The expert system
contains a knowledge base about the runtime devices (named Device Features Database Model)
and a set of formulas (named Domain Specific Profiling Analysis Transformation Library),
currently represented by model transformations. The different formulas represent the expert
system heart and take into account two information sources, the profiling tool and the knowledge
base.
In this section, we present the expert system, handling both information sources to produce high-
level information intended for the models designers.
6.1. An Expert System to Produce Advices
More than profiling results, we are able to provide smart advices to the model designers. The
expert system uses the profiling logs that give factual data about execution whereas the hardware
knowledge base gives features about the runtime platform. By combining both sources with
dedicated analysis, it is possible to deduce how to improve the execution of the generated code.
For instance, assuming the device supports 32MB in shared memory allocation per thread group
and the application allocates at runtime 48MB. The expert system is able to indicate that it is
necessary to decrease the memory allocation after analysing profiling log results and device
constraints. In this case, the expert system provides a hint, in the designed model, where the
problem occurs. In order to analyse the many properties of the results, an extensible library (cf.
Figure 7) is proposed in this paper.
Figure 7. Approach Overview
14. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
14
6.2. Smart Advice Computation
The expert system includes a number of algorithms that can estimate the best values to specify in
the high level model in order to improve the modelled software performances. These algorithms
are implemented by model transformations. We use model transformations for the simplicity and
convenience of handling input models they provide (obviously, any programming language with
the ability to navigate and produce models can be used for writing the algorithms). The results
produced by the algorithm are presented in an advice model.
6.3. Backtracking Advices in the Input Models
As for each LogEntry of the profiling model, the advices computed by the expert system are
reported in the high-level models. As each Advice owns a UID attribute, inherited from the
profiling model, the advice feedback is performed as for the LogEntry. The Advice body attribute
contains the computed advice, as well as the profiling information. Thus, only one backward
navigation algorithm is used.
7. CASE STUDY: DAXPY MODEL
In this section, we show how the GPU knowledge base is build and how the advice proposed by
our expert system can help to modify high-level models and improve GPU performances for the
Conjugate Gradient algorithm.
7.1. Creating the GPU knowledge base
In the OpenCL transformation chain context, the hardware knowledge base must be built for
GPUs. The metamodel we obtain and we consider in this section is the one illustrated in Figure 8.
It is obvious that the device features models produced from this metamodel, GPUs oriented, must
be produced by GPU experts.
Figure 8. GPUs Device Features Metamodel
In Figure 8 we have two enumerations: ComputeCapability and AllocationGranularity. These two
enumerations are used by the attributes CC and AG from the GPU_Device metaclass. The first
attribute represents the GPU computing capacity (e.g, cc10 represents the computing capacity
15. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
15
version 1.0). The second attribute represents the granularity of the allocations performed by the
GPU.
As an example, Figure 9 shows an excerpt of the device feature model (hardware knowledge
base) for GPU devices. In this excerpt, 10 NVidia’ (here a.k.a. GPU 1.3) features are shown. The
highlighted feature: TW, gives a number of 32 threads per Warp (or work-items in OpenCL
terminology). This information represents the quantity of threads that can be active at the same
time on the hardware. Although this metamodel was designed according to vendor’s features, it
can be modified or extended to comply with other vendor device models.
Figure 9. GPU Device Features Database Model
7.2. Analyzing Processor Occupancy on BLAS DAXPY Operations
DAXPY is essentially an O(N) parallel operation. It is a linear combination of vectors y = αx+y.
The UML-MARTE model for the DAXPY present in the CG application is shown in Figure 10b.
The application’s vectors are arrays of 775,689 elements. This number results from the model of
an alternator from VALEO and takes advantage of the massively parallel processors provided by
GPUs. This operation as the previous one is part of simulation tool that had its performance
improved, resulting in a global speedup of the order of 9x. This result is particularly valuable to
VALEO for larger simulations that require long time to finish. The composed component DAXPY
instantiated in the program consists of a repetitive task xy:DaxpyGroup. In our application, this
kind of task is composed by operations on single elements. Repetitive tasks are potentially
parallel and are allocated onto GPU.
The repetition shape of the task in this case is {16,48494}, i.e. the task operation runs 775,696
(the product of the shape) millions times on one element of each vector whose size equals
775,689. The total of work-items is calculated by multiplying the dimensions of the task
hierarchy. The first one becomes the number of work-items and the second one the number of
groups. The definition of this shape is a decision of the designers and usually they take into
account the Intellectual Property (IP) interface associated to the elementary task and its external
tilers [4]. Moreover, considering that, in “compute capability” 1.x GPU devices, memory
transfers and instruction dispatch occur at the Half-Warp (16 work-items) granularity, it is
reasonable to define groups composed of work-items at a first try.
16. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
16
Once the application is designed with all necessary elements, we generate all source code files. In
addition, trace models are generated for each model-to-model transformation thanks to the
traceability mechanism.
7.3. Profiling Feedback
Among all the measures coming from the profiler, the kernel occupancy factor has an important
impact on performance. Usually the aim at executing a kernel is to keep the multiprocessors and,
consequently, the devices as busy as possible. The work-items instructions are executed
sequentially in OpenCL, and, as a result, executing other warps when one warp is paused or
stalled is the only way to hide latencies and keep the hardware busy. Some metric related to the
number of active warps on a multiprocessor is therefore important in determining how effectively
the hardware is kept busy. This metric is called occupancy. The occupancy is the ratio of the
number of active warps per multiprocessor (WPM) to the maximum number of possible active
warps. Another way to view occupancy is the percentage of the hardware’s ability to process
warps that are actively in use. Hence, higher occupancy does not always equate to higher
performance, there is a point above where additional occupancy does not improve performance.
However, low occupancy always interferes with the ability to hide memory latency, resulting in
performance degradation.
The important features to compute the occupancy vary on the different GPU “compute capability”
are:
• the number of registers available;
• the maximum number of simultaneous work-items resident on each multiprocessor;
• and the register allocation granularity.
The number of work-items resident on a multiprocessor relies on index space as known as N-
Dimensional Range (NDRange). The OpenCL chain computes the information from the shape of
the task, which will become a kernel. Hence, changes in the dimensions of shape affect the
occupancy. From the point of view of the proposed approach, occupancy is a specialized module
that can be included to the expert system. For other analysis other specialized module can be
added to attain specific goals. For this example, we analyze the occupancy of the multiprocessors.
Occupancy is function of constant parameters (features) from device and some measures directly
obtained from the profiler.
The process of calculating occupancy is implemented in a QVT transformation. This
transformation takes two input models (according to Figure 7): the Device Features Database and
the Profiling Logs. In this example the first one conforms to a metamodel based on NVidia GPUs.
For instance, from the model presented in Figure 10a we see that the GPU Tesla T10 has
computed capability equals 1.3 and its warps contain 32 threads (or work-items in OpenCL
terminology).
7.4. Benchmarking
For this example the first running gives the results illustrated in Figure 10a. The application
launches 48,481 groups of 16 work-items onto the device. Figure 10a shows that we got only
25% (0.250) of the multiprocessor occupancy. Our goal is to increase the occupancy and decrease
the relative GPU execution time.
17. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
17
Figure 10a. GPU Device Features Database
Model
Figure 10b. GPU Device Features Database Model
By using our approach results are combined with GPU features and this returns a smart advice as
comment in the input UML-MARTE model (Figure 10b). Besides the performance parameters
available directly on the comment, a hint points out a possible change in the model to improve the
generated code. Additionally, the advice provides an image reference of a chart (as seen in Figure
11) for all predicted occupancy according to these results. In this case it is suggested to change
the task shape from {16, 48481} to {128, 6061}.
A simple analysis search for the first block size gives us 100% occupancy. For instance, the
expert system automatically highlights the first (block size=128) and second (block size=256)
maximum values in the chart.
Figure 11 – Occupancy by Varying Block Size
After executing the modified application, we have 100% on occupancy and a reduction of the
GPU time as it is shown in the new profiling log (Listing 3, line 8). Previously we had 278.912μs,
and then the GPU time decreased to 82.048μs. As expected, the modified model achieves better
performance than the original one. The whole execution of the kernel is about 2.3x faster.
8. CONCLUSION AND FUTURE DIRECTIONS
In this paper we address performance improvements as part of the life cycle of the application
design and execution. We provide a high level profiling environment for MDE compiler that we
applied for OpenCL in the context of the Gaspard2 environment. This environment allows the
18. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
18
model designers to efficiently modify their models to achieve better performances. The profiling
environment is based on two main artifacts: an expert system and a traceability mechanism.
The expert system proposed here uses data from a feature database dedicated to the runtime
platform and profiling logs. The aim is to compute a smart advice explaining how the model
should be modified in order to achieve better performances. From the application designers point
of view, they do not necessarily need to know complex details about the runtime platform.
Moreover, no performance specification is given in advance. The expert system summarizes the
profiling logs and minimizes the tasks of the model designer by analyzing the gathered profiling
data.
Especially for GPU applications, better performances rely on speedup, memory use and processor
occupancy. In order to provide this feedback, this paper proposed to retain coherence between
code generation and traceability. Thus, the expert system uses the traceability to return a UML
comment consisting of a computed smart advice and profiling logs on the specific input model
elements that involve the analyzed performance issue.
Obviously, although our case study is focused on GPU applications, our approach can be adapted
to other environments with code generation and profiling tools. Indeed, as we have shown in the
paper, the library that is part of the expert system can be extended to analyze other issues or other
devices. Moreover, the traceability mechanism that we provide can fit to any transformation
19. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
19
[3] Antonia Bertolino and Raffaela Mirandola. Towards Component- Based Software Performance
Engineering. In Component-Based Software Engineering, 2003.
[4] Pierre Boulet. Array-OL Revisited, Multidimensional Intensive Signal Processing Specification.
Technical report, 2007. Available from: http://hal.inria.fr/inria-00128840/PDF/RR-6113v2.pdf.
[5] Mathias Fritzsche and Wasif Gilani. Model transformation chains and model management for end-to-
end performance decision support. In Proceedings of the 3rd international summer school conference
on Generative and transformational techniques in software engineering III, GTTSE’09, pages 345–
363, Berlin, Heidelberg, 2011. Springer-Verlag. Available from:
http://portal.acm.org/citation.cfm?id= 1949925.1949936.
[6] Mathias Fritzsche, Jendrik Johannes, Steen Zschaler, Anatoly Zherebtsov, and Alexander Terekhov.
Application of Tracing Techniques in Model-Driven Performance Engineering. In In Proccedings of
the 4th ECMDA-Traceability Workshop (ECMDA’08, June 2008.
[7] A. Gamatié, S. Le Beux, E. Piel, R. Ben Atitallah, A. Etien, P. Marquet, and J-L. Dekeyser. A Model
Driven Design Framework for Massively Parallel Embedded Systems. ACM Transactions on
Embedded Computing Systems (TECS)., 10(4), 2011.
[8] E. Gómez-Martínez and J. Merseguer. ArgoSPE: Model-based Software Performance Engineering.
volume 4024, pages 401–410. Springer-Verlag, Springer-Verlag, 2006.
[9] Khronos Group. OpenCL - The open standard for parallel programming of heterogeneous systems.
http://www.khronos.org/opencl/. Available from: http://www.khronos.org/opencl/.
[10] Sébastien Le Beux. Un Flot de Conception pour Applications de Traitement du Signal Systématique
Implémentées sur FPGA à Base d’Ingénierie Dirigée par les Modèles. These, Université des Sciences
et Technologie de Lille, December 2007.
[11] NVIDIA. Compute Visual Profiler. http://developer.
download.nvidia.com/compute/cuda/4_0_rc2/toolkitMdocs/
VisualProfiler/Compute_Visual_Profiler_User_Guide.pdf, 2010.
[12] OMG. UML Profile for Schedulability, Performance, and Time, version 1.1.
http://www.omg.org/spec/SPTP, 2005. Available from: http://www.omg.org/spec/SPTP.
[13] OMG. Modeling and Analysis of Real-time and Embedded systems (MARTE), Version 1.0.
http://www.omg.org/spec/MARTE/1.0/, 2009. Available from:
http://www.omg.org/spec/MARTE/1.0/.
[14] Gøran Olsen and Jon Oldevik. Scenarios of Traceability in Model to Text Transformations. In Model
Driven Architecture- Foundations and Applications, Lecture Notes in Computer Science. 2007.
[15 ]Dorina C. Petriu and Hui Shen. Applying the uml performance profile: Graph grammar-based
derivation of lqn models from uml specifications. In Proceedings of the 12th International Conference
on Computer Performance Evaluation, Modelling Techniques and Tools, TOOLS ’02, pages 159–
177, London, UK, 2002. Springer-Verlag. Available from:
http://portal.acm.org/citation.cfm?id=647810. 737982.
[16] A. Wendell O. Rodrigues, Frédéric Guyomarch, and Jean-Luc Dekeyser. An MDE Approach for
Automatic Code Generation from MARTE to OpenCL. Technical report, INRIA Lille - RR-7525,
2011. http://hal.inria.fr/inria-00563411/PDF/RR-7525.pdf/.
[17] A. Wendell O. Rodrigues, Frédéric Guyomarch, and Jean-Luc Dekeyser. An MDE Approach for
Automatic Code Generation from UML/MARTE to OpenCL. IEEE Computer in Science &
Engineering - Special Edition on GPUs, Journal, Jan 2012.
[18] A. Wendell O. Rodrigues. A Methodology to Develop High Performance Applications on GPGPU
Architectures: Application to Simulation of Electrical Machines. Thesis, Université de Lille 1, Jan-
uary 2012. Available from: http://tel.archives-ouvertes.fr/ tel-00670221.
[19] Connie U. Smith and Lloyd G. Williams. Performance Solutions: A Practical Guide to Creating
Responsive, Scalable Software. Addison Wesley Longman Publishing Co., Inc, 2002.
[20] I. Traore, I. Woungang, A.A. El Sayed Ahmed, and M.S. Obaidat. UML-based Performance
Modeling of Distributed Software Systems. In Performance Evaluation of Computer and
Telecommunication Systems (SPECTS), pages 119 –126, july 2010.
[21] C.M. Woodside. Tutorial Introduction to Layered Modeling of Software Performance. Technical
report, Department of Systems and Computer Engineering, Carleton University, Ottawa (Canada),
2002.
20. International Journal of Software Engineering & Applications (IJSEA), Vol.5, No.4, July 2014
20
Authors
Vincent Aranega received his PhD degree in Computer Science at University of Lille 1 -
France in 2011. His research interest includes Model Driver Engineering and more
specifically model transformation languages and chaining. He works on the use of model
transformation traceability for debugging and profiling purposes.
A. Wendell O. Rodrigues obtained his Ph.D. degree in Computer Science at University of
Lille1 - France in 2012. His research interests include parallel architectures and
programming, and software engineering, specifically with regards to GPUs and high-level
software specification. Rodrigues is currently assistant professor at Federal Institute of
Education, Science and Technology of Ceará.
Anne Etien received a Ph.D. degree in Computer Science from the University of Paris 1
Pantheon-Sorbonne, France in 2006. She is now Associate Professor in the University of
Lille 1 in France and makes her research at the LIFL. Her area of interest includes model
driven engineering. More specifically, she works on various aspects of model
transformations, including chaining, evolution, reusability, traceability, genericity.
Frédéric Guyomarch got his PhD in Computer Science in 2000 and is currently assistant
profeesor at the University of Lille 1 - France. His research interests focus on high
performance computing, from the algorithms for numerical computation to compilation
technics to generate optimized code for such algorithms.
Jean-Luc Dekeyser received his PhD degree in computer science from the university of
Lille in 1986. He was a fellowship at CERN. After a few years at the Supercomputing
Computation Research Institute in Florida State University, he joined in 1988 the
University of Lille in France as an assistant professor. He created a research group working
on High Performance Computing in the CNRS lab in Lille. He is currently Professor in
computer science at University of Lille. His research interests include embedded systems,
System on Chip co-design, synthesis and simulation, performance evaluation, high performance
computing, model driven engineering, dynamic reconfiguration, Chip-3D.