Spelling suggestions: "subject:"codegeneration"" "subject:"vasodegeneration""
131 |
Gera??o autom?tica de hardware a partir de especifica??es formais: estendendo uma abordagem de tradu??oMedeiros Junior, Ivan Soares de 27 April 2012 (has links)
Made available in DSpace on 2014-12-17T15:48:02Z (GMT). No. of bitstreams: 1
IvanSMJ_DISSERT.pdf: 2894212 bytes, checksum: 3acb921ac87239ee36be60cb2e15b0e6 (MD5)
Previous issue date: 2012-04-27 / Coordena??o de Aperfei?oamento de Pessoal de N?vel Superior / Removing inconsistencies in a project is a less expensive activity when done in the
early steps of design. The use of formal methods improves the understanding of systems.
They have various techniques such as formal specification and verification to identify
these problems in the initial stages of a project. However, the transformation from a
formal specification into a programming language is a non-trivial task and error prone,
specially when done manually. The aid of tools at this stage can bring great benefits to
the final product to be developed.
This paper proposes the extension of a tool whose focus is the automatic translation of
specifications written in CSPM into Handel-C. CSP is a formal description language suitable
for concurrent systems, and CSPM is the notation used in tools support. Handel-C is a
programming language whose result can be compiled directly into FPGA s. Our extension
increases the number of CSPM operators accepted by the tool, allowing the user to define
local processes, to rename channels in a process and to use Boolean guards on external
choices. In addition, we also propose the implementation of a communication protocol
that eliminates some restrictions on parallel composition of processes in the translation
into Handel-C, allowing communication in a same channel between multiple processes to
be mapped in a consistent manner and that improper communication in a channel does
not ocurr in the generated code, ie, communications that are not allowed in the system
specification / A remo??o de inconsist?ncias em um projeto ? menos custosa quando realizada nas
etapas iniciais da sua concep??o. A utiliza??o de M?todos Formais melhora a compreens?o
dos sistemas al?m de possuir diversas t?cnicas, como a especifica??o e verifica??o
formal, para identificar essas inconsist?ncias nas etapas iniciais de um projeto. Por?m, a
transforma??o de uma especifica??o formal para uma linguagem de programa??o ? uma
tarefa n?o trivial. Quando feita manualmente, ? uma tarefa pass?vel da inser??o de erros.
O uso de ferramentas que auxiliem esta etapa pode proporcionar grandes benef?cios ao
produto final que ser? desenvolvido.
Este trabalho prop?e a extens?o de uma ferramenta cujo foco ? a tradu??o autom?tica
de especifica??es em CSPM para Handel-C. CSP ? uma linguagem de descri??o formal
adequada para trabalhar com sistemas concorrentes, CSPM ? a nota??o utilizada pelas
ferramentas de apoio da linguagem. Handel-C ? uma linguagem de programa??o cujo
resultado pode ser compilado diretamente para FPGA s. A extens?o consiste no aumento
no n?mero de operadores CSPM aceitos pela ferramenta, permitindo ao usu?rio definir
processos locais, renomear canais e utilizar guarda booleana em escolhas externas. Al?m
disto, propomos tamb?m a implementa??o de um protocolo de comunica??o que elimina
algumas restri??es da composi??o paralela de processos na tradu??o para Handel-C, permitindo
que a comunica??o em um mesmo canal entre m?ltiplos processos possa ser mapeada
de maneira consistente e que no c?digo gerado n?o ocorra comunica??es indevidas
em um canal, ou seja, comunica??es que n?o s?o permitidas na especifica??o do sistema
|
132 |
Décomposition formelle des spécifications centralisées Event-B : application aux systèmes distribués BIP / Formal decomposition of event-B centralized specifications : application to BIP distributed systemsSiala, Badr 15 December 2017 (has links)
Cette thèse a pour cadre scientifique la décomposition formelle des spécifications centrali- sées Event-B appliquée aux systèmes distribués BIP. Elle propose une démarche descendante de développement des systèmes distribués corrects par construction en combinant judicieu- sement Event-B et BIP. La démarche proposée comporte trois étapes : Fragmentation, Dis- tribution et Génération de code BIP. Les deux concepts clefs Fragmentation et Distribution, considérés comme deux sortes de raffinement automatique Event-B paramétrées à l'aide de deux DSL appropriés, sont introduits par cette thèse. Cette thèse apporte également une contribution au problème de la génération de code à partir d'un modèle Event-B issu de l'étape de distribution. Nous traitons aussi bien les aspects architecturaux que comportemen- taux. Un soin particulier a été accordé à l'outillage et l'expérimentation de cette démarche. Pour y parvenir, nous avons utilisé l'approche IDM pour l'outillage et l'application Hôtel à clés électroniques pour l'expérimentation. / The scientific framework of this thesis is the formal decomposition of the centralized specifications Event-B applied to distributed systems based on the BIP (Behavior, Interaction, Priority) component framework. It suggets a top-down approach to the development of correct by construction distributed systems by judiciously combining Event-B and BIP. The proposed approach consists in three steps : Fragmentation, Distribution and Generation of BIP code. We introduce two key concepts, Fragmentation and Distribution, which are considered as two kinds of automatic refinement of Event-B models. They are parameterized using two appropriate DSL. This thesis also contributes to the problem of code generation from Event- B models resulting from the Distribution step. Accordingly, we deal with both architectural and behavioral aspects. A special care has been devoted to the implementation and the experimentation of this approach. To achieve this, we have used the IDM approach for tooling and the Electronic Hotel Key System for experimentation.
|
133 |
An aspect-oriented model-driven engineering approach for distributed embedded real-time systems / Uma abordagem de engenharia guiada por modelos para o projeto de sistemas tempo-real embarcados e distribuídosWehrmeister, Marco Aurélio January 2009 (has links)
Atualmente, o projeto de sistemas tempo-real embarcados e distribuídos está crescendo em complexidade devido à sua natureza heterogênea e ao crescente número e diversidade de funções que um único sistema desempenha. Sistemas de automação industrial, sistemas eletrônicos em automóveis e veículos aéreos, equipamentos médicos, entre outros, são exemplos de tais sistemas. Tais sistemas são compostos por componentes distintos (blocos de hardware e software), os quais geralmente são projetados concorrentemente utilizando modelos, ferramentas e linguagens de especificação e implementação diferentes. Além disso, estes sistemas tem requisitos específicos e importantes, os quais não representam (por si só) as funcionalidades esperadas do sistema, mas podem afetar a forma como o sistema executa suas funcionalidades e são muito importantes para a realização do projeto com sucesso. Os chamados requisitos não-funcionais são difíceis de tratar durante todo o ciclo de projeto porque normalmente um único requisito não-funcional afeta vários componentes diferentes. A presente tese de doutorado propõe a integração automatizada das fases de projeto de sistemas tempo-real embarcados e distribuídos focando em aplicações na área da automação. A abordagem proposta usa técnicas de engenharia guiada por modelos (do inglês Model Driven Engineering ou MDE) e projeto orientado a aspectos (do inglês Aspect-Oriented Design ou AOD) juntamente com o uso de plataformas previamente desenvolvidas (ou desenvolvida por terceiros) para projetar os componentes de sistemas tempo-real embarcados e distribuídos. Adicionalmente, os conceitos de AOD permitem a separação no tratamento dos requisitos de naturezas diferentes (i.e. requisitos funcionais e não-funcionais), melhorando a modularização dos artefatos produzidos (e.g. modelos de especificação, código fonte, etc.). Além disso, esta tese propõe uma ferramenta de geração de código, que suporta a transição automática das fases iniciais de especificação para as fases seguintes de implementação. Esta ferramenta usa um conjunto de regras de mapeamento, que descrevem como elementos nos níveis mais altos de abstração são mapeados (ou transformados) em elementos dos níveis mais baixos de abstração. Em outras palavras, tais regras de mapeamento permitem a transformação automática da especificação inicial, as quais estão mais próximo do domínio da aplicação, em código fonte para os componentes de hardware e software, os quais podem ser compilados e sintetizados por outras ferramentas para se obter a realização/implementação do sistema tempo-real embarcado e distribuído. / Currently, the design of distributed embedded real-time systems is growing in complexity due to the increasing amount of distinct functionalities that a single system must perform, and also to concerns related to designing different kinds of components. Industrial automation systems, embedded electronics systems in automobiles or aerial vehicles, medical equipments and others are examples of such systems, which includes distinct components (e.g. hardware and software ones) that are usually designed concurrently using distinct models, tools, specification, and implementation languages. Moreover, these systems have domain specific and important requirements, which do not represent by themselves the expected functionalities, but can affect both the way that the system performs its functionalities as well as the overall design success. The so-called nonfunctional requirements are difficult to deal with during the whole design because usually a single non-functional requirement affects several distinct components. This thesis proposes an automated integration of distributed embedded real-time systems design phases focusing on automation systems. The proposed approach uses Model- Driven Engineering (MDE) techniques together with Aspect-Oriented Design (AOD) and previously developed (or third party) hardware and software platforms to design the components of distributed embedded real-time systems. Additionally, AOD concepts allow a separate handling of requirement with distinct natures (i.e. functional and non-functional requirements), improving the produced artifacts modularization (e.g. specification model, source code, etc.). In addition, this thesis proposes a code generation tool, which supports an automatic transition from the initial specification phases to the following implementation phases. This tool uses a set of mapping rules, describing how elements at higher abstraction levels are mapped (or transformed) into lower abstraction level elements. In other words, suchmapping rules allow an automatic transformation of the initial specification, which is closer to the application domain, in source code for software and hardware components that can be compiled or synthesized by other tools, obtaining the realization/ implementation of the distributed embedded real-time system.
|
134 |
An approach for embedded software generation based in declarative alloy models / Uma abordagem para geração de software embarcado baseada em modelos declarativos alloySpecht, Emilena January 2008 (has links)
Este trabalho propõe uma nova abordagem para o desenvolvimento de sistemas embarcados, através da combinação da abstração e propriedades de verificação de modelos da linguagem declarativa Alloy com a ampla aceitação de Java na indústria. A abordagem surge no contexto de que a automação de software no domínio embarcado tornou-se extremamente necessária, uma vez que atualmente a maior parte do tempo de desenvolvimento é gasta no projeto de software de produtos tão restritos em termos de recursos. As ferramentas de automação de software embarcado devem atender a demanda por produtividade e manutenibilidade, mas respeitar restrições naturais deste tipo de sistema, tais como espaço de memória, potência e desempenho. As ferramentas de automação de projeto lidam com produtividade e manutenibilidade ao permitir especificações de alto nível, tarefa difícil de atender no domínio embarcado devido ao comportamento misto de muitas aplicações embarcadas. Abordagens que promovem meios para verificação formal também são atrativas, embora geralmente sejam difíceis de usar, e por este motivo não são de grande auxílio na tarefa de reduzir o tempo de chegada ao mercado do produto. Através do uso de Alloy, baseada em lógica de primeira-ordem, é possível obter especificações em altonível e verificação formal de modelos com uma única linguagem. Este trabalho apresenta a poderosa abstração proporcionada pela linguagem Alloy em aplicações embarcadas, assim como regras para obter automaticamente código Java a partir de modelos Alloy. A geração de código Java a partir de modelos Alloy, combinada a uma ferramenta de estimativa, provê exploração de espaço de projeto, atendendo assim as fortes restrições do projeto de software embarcado, o que normalmente não é contemplado pela engenharia de software tradicional. / This work proposes a new approach for embedded software development, by combining the abstraction and model verification properties of the Alloy declarative language with the broad acceptance in industry of Java. The approach comes into play since software automation in the embedded domain has become a major need, as currently most of the development time is spent designing software for such hardconstrained resources products. Design automation tools for embedded systems must meet the demand for productivity and maintainability, but constraints such as memory, power and performance must still be considered. Design automation tools deal with productivity and maintainability by allowing high-level specifications, which is hard to accomplish on the embedded domain due to the mixed behavior nature of many embedded applications. Approaches that provide means for formal verification are also attractive, but their usage is usually not straightforward, and for this reason they are not that helpful in dealing with time-tomarket constraints. By using Alloy, based in first-order logic, it is possible to obtain high-level specifications and formal model verification with a single language. This work shows the powerful abstraction provided by the Alloy language for embedded applications, as well as rules for obtaining automatically Java code from Alloy models. The Java source code generation from Alloy models, combined with an estimation tool, provides design space exploration to match tight embedded software design constraints, what is usually not taken into account by standard software engineering techniques.
|
135 |
Formal Guaranties for Safety Critical Code Generation : the Case of Highly Variable Languages / Garanties formelles pour la génération de code critique : L’affaire des langages fortement variablesDieumegard, Arnaud 30 January 2015 (has links)
Les fonctions de commande et de contrôle sont parmi les plus importantes des systèmes embarqués critiques utilisés dans des activités telles les transports, la santé ou la gestion de l’énergie. Leur impact potentiel sur la sûreté de fonctionnement fait de la vérification de leur correction l’un des points les plus critiques de leur développement. Cette vérification est usuellement effectuée en accord avec les normes de certification décrivant un ensemble d’objectifs à atteindre afin d’assurer un haut niveau de qualité du système et donc de prévenir l’apparition de défauts. Cette vérification du logiciel est traditionnellement basée sur de nombreux tests et des activitiés de relectures de code, toutefois les versions les plus récentes des standards de certification permettent l’utilisation de nouvelles approches de développement telles que l’ingénierie dirigée par les modèles et les méthodes formelles ainsi que l’utilisation d’outil pour assister les processus de développement. Les outils de génération automatique de code sont exploités dans la plupart des processus de développement de systèmes embarqués critiques afin d’éviter des erreurs de programmation liées à l’humain et pour assurer le respect des règles de production de code. Ces outils ayant pour vocation de remplacer les humains pour la production de code, des erreurs dans leur conception peuvent causer l’apparition d’erreurs dans le code généré. Il est donc nécessaire de vérifier que le niveau de qualité de l’outil est le même que celui du code produit en s’assurant que les objectifs spécifiées dans les normes de qualification sont couverts. Nos travaux visent à exploiter l’ingénierie dirigée par les modèles et les méthodes formelles pour développer ces outils et ainsi atteindre un niveau de qualité plus élevé que les approches traditionnelles. Les fonctions critiques de commande et de contrôle sont en grande partie conçues à l’aide de langages graphiques à flot de données. Ces langages sont utilisés pour modéliser des systèmes complexes à l’aide de blocs élémentaires groupés dans des librairies de blocs. Un bloc peut être un objet logiciel sophistiqué exposant une haute variabilité tant structurelle que sémantique. Cette variabilité est à la fois liée aux valeurs des paramètres du bloc ainsi qu’à son contexte d’utilisation. Dans notre travail, nous concentrons notre attention en premier lieu sur la spécification formelle de ces blocs ainsi que sur la vérification de ces spécifications. Nous avons évalué plusieurs approches et techniques dans le but d’assurer une spécification formelle, structurellement cohérente, vérifiable et réutilisable des blocs. Nous avons finalement conçu un langage basé sur l’ingénierie dirigées par les modèles dédié à cette tâche. Ce langage s’inspire des approches des lignes de produit logiciel afin d’assurer une gestion de la variabilité des blocs à la fois correcte et assurant un passage à l’échelle. Nous avons appliqué cette approche et la vérification associée sur quelques exemples choisis de blocs issus d’applications industrielles et l’avons validé sur des prototypes logiciels que nous avons développé. Les blocs sont les principaux éléments des langages d’entrée utilisés pour la génération automatique de logiciels de commande et de contrôle. Nous montrons comment les spécifications formelles de blocs peuvent être transformées en des annotations de code afin de simplifier et d’automatiser la vérification du code généré. Les annotations de code sont vérifiées par la suite à l’aide d’outils spécialisés d’analyse statique de code. En utilisant des observateur synchrones pour exprimer des exigences de haut niveau sur les modèles en entrée du générateur, nous montrons comment la spécification formelle de blocs peut être utilisée pour la génération d’annotations de code et par la suite pour la vérification automatique des exigences. / Control and command softwares play a key role in safety-critical embedded systems used for human related activities such as transportation, healthcare or energy. Their impact on safety makes the assessment of their correctness the central point in their development activities. Such systems verification activities are usually conducted according to normative certification guidelines providing objectives to be reached in order to ensure development process reliability and thus prevent flaws. Verification activities usually relies on tests and proof reading of the software but recent versions of certification guidelines are taking into account the deployment of new development paradigms such as model-based development, and formal methods; or the use of tools in assistance of the development processes. Automatic code generators are used in most safety-critical embedded systems development in order to avoid human related software production errors and to ensure the respect of development quality standards. As these tools are supposed to replace humans in the software code production activities, errors in these tools may result in embedded software flaws. It is thus in turn mandatory to ensure the same level of correctness for the tool itself than for the expected produced code. Tools verification shall be done according to qualification guidelines. We advocate in our work the use of model-based development and formal methods for the development of these tools in order to reach a higher quality level. Critical control and command software are mostly designed using graphical dataflow languages. These languages are used to express complex systems relying on atomic operations embedded in blocks that are gathered in block libraries. Blocks may be sophisticated pieces of software with highly variable structure and semantics. This variability is dependent on the values of the block parameters and of the block's context of use. In our work, we focus on the formal specification and verification of such block based languages. We experimented various techniques in order to ensure a formal, sound, verifiable and usable specification for blocks. We developed a domain specific formal model-based language specifically tailored for the specification of structure and semantics of blocks. This specification language is inspired from software product line concepts in order to ensure a correct and scalable management of the blocks variability. We have applied this specification and verification approach on chosen block examples from common industrial use cases and we have validated it on tool prototypes. Blocks are the core elements of the input language of automatic code generators used for control and command systems development. We show how our blocks formal specification can be translated as code annotations in order to ease and automate the generated code verification. Code annotations are verified using specialised static code analysis tools. Relying on synchronous observers to express high level requirements at the input model level, we show how formal block specification can also be used for the translation of high level requirements as verifiable code annotations discharged using the same specialised tooling. We finally target the assistance of code generation tools qualification activities by arguing on the ability to automatically generate qualification data such as requirements, tests or simulation results for the verification and development of automatic code generators from the formal block specification.
|
136 |
An aspect-oriented model-driven engineering approach for distributed embedded real-time systems / Uma abordagem de engenharia guiada por modelos para o projeto de sistemas tempo-real embarcados e distribuídosWehrmeister, Marco Aurélio January 2009 (has links)
Atualmente, o projeto de sistemas tempo-real embarcados e distribuídos está crescendo em complexidade devido à sua natureza heterogênea e ao crescente número e diversidade de funções que um único sistema desempenha. Sistemas de automação industrial, sistemas eletrônicos em automóveis e veículos aéreos, equipamentos médicos, entre outros, são exemplos de tais sistemas. Tais sistemas são compostos por componentes distintos (blocos de hardware e software), os quais geralmente são projetados concorrentemente utilizando modelos, ferramentas e linguagens de especificação e implementação diferentes. Além disso, estes sistemas tem requisitos específicos e importantes, os quais não representam (por si só) as funcionalidades esperadas do sistema, mas podem afetar a forma como o sistema executa suas funcionalidades e são muito importantes para a realização do projeto com sucesso. Os chamados requisitos não-funcionais são difíceis de tratar durante todo o ciclo de projeto porque normalmente um único requisito não-funcional afeta vários componentes diferentes. A presente tese de doutorado propõe a integração automatizada das fases de projeto de sistemas tempo-real embarcados e distribuídos focando em aplicações na área da automação. A abordagem proposta usa técnicas de engenharia guiada por modelos (do inglês Model Driven Engineering ou MDE) e projeto orientado a aspectos (do inglês Aspect-Oriented Design ou AOD) juntamente com o uso de plataformas previamente desenvolvidas (ou desenvolvida por terceiros) para projetar os componentes de sistemas tempo-real embarcados e distribuídos. Adicionalmente, os conceitos de AOD permitem a separação no tratamento dos requisitos de naturezas diferentes (i.e. requisitos funcionais e não-funcionais), melhorando a modularização dos artefatos produzidos (e.g. modelos de especificação, código fonte, etc.). Além disso, esta tese propõe uma ferramenta de geração de código, que suporta a transição automática das fases iniciais de especificação para as fases seguintes de implementação. Esta ferramenta usa um conjunto de regras de mapeamento, que descrevem como elementos nos níveis mais altos de abstração são mapeados (ou transformados) em elementos dos níveis mais baixos de abstração. Em outras palavras, tais regras de mapeamento permitem a transformação automática da especificação inicial, as quais estão mais próximo do domínio da aplicação, em código fonte para os componentes de hardware e software, os quais podem ser compilados e sintetizados por outras ferramentas para se obter a realização/implementação do sistema tempo-real embarcado e distribuído. / Currently, the design of distributed embedded real-time systems is growing in complexity due to the increasing amount of distinct functionalities that a single system must perform, and also to concerns related to designing different kinds of components. Industrial automation systems, embedded electronics systems in automobiles or aerial vehicles, medical equipments and others are examples of such systems, which includes distinct components (e.g. hardware and software ones) that are usually designed concurrently using distinct models, tools, specification, and implementation languages. Moreover, these systems have domain specific and important requirements, which do not represent by themselves the expected functionalities, but can affect both the way that the system performs its functionalities as well as the overall design success. The so-called nonfunctional requirements are difficult to deal with during the whole design because usually a single non-functional requirement affects several distinct components. This thesis proposes an automated integration of distributed embedded real-time systems design phases focusing on automation systems. The proposed approach uses Model- Driven Engineering (MDE) techniques together with Aspect-Oriented Design (AOD) and previously developed (or third party) hardware and software platforms to design the components of distributed embedded real-time systems. Additionally, AOD concepts allow a separate handling of requirement with distinct natures (i.e. functional and non-functional requirements), improving the produced artifacts modularization (e.g. specification model, source code, etc.). In addition, this thesis proposes a code generation tool, which supports an automatic transition from the initial specification phases to the following implementation phases. This tool uses a set of mapping rules, describing how elements at higher abstraction levels are mapped (or transformed) into lower abstraction level elements. In other words, suchmapping rules allow an automatic transformation of the initial specification, which is closer to the application domain, in source code for software and hardware components that can be compiled or synthesized by other tools, obtaining the realization/ implementation of the distributed embedded real-time system.
|
137 |
An approach for embedded software generation based in declarative alloy models / Uma abordagem para geração de software embarcado baseada em modelos declarativos alloySpecht, Emilena January 2008 (has links)
Este trabalho propõe uma nova abordagem para o desenvolvimento de sistemas embarcados, através da combinação da abstração e propriedades de verificação de modelos da linguagem declarativa Alloy com a ampla aceitação de Java na indústria. A abordagem surge no contexto de que a automação de software no domínio embarcado tornou-se extremamente necessária, uma vez que atualmente a maior parte do tempo de desenvolvimento é gasta no projeto de software de produtos tão restritos em termos de recursos. As ferramentas de automação de software embarcado devem atender a demanda por produtividade e manutenibilidade, mas respeitar restrições naturais deste tipo de sistema, tais como espaço de memória, potência e desempenho. As ferramentas de automação de projeto lidam com produtividade e manutenibilidade ao permitir especificações de alto nível, tarefa difícil de atender no domínio embarcado devido ao comportamento misto de muitas aplicações embarcadas. Abordagens que promovem meios para verificação formal também são atrativas, embora geralmente sejam difíceis de usar, e por este motivo não são de grande auxílio na tarefa de reduzir o tempo de chegada ao mercado do produto. Através do uso de Alloy, baseada em lógica de primeira-ordem, é possível obter especificações em altonível e verificação formal de modelos com uma única linguagem. Este trabalho apresenta a poderosa abstração proporcionada pela linguagem Alloy em aplicações embarcadas, assim como regras para obter automaticamente código Java a partir de modelos Alloy. A geração de código Java a partir de modelos Alloy, combinada a uma ferramenta de estimativa, provê exploração de espaço de projeto, atendendo assim as fortes restrições do projeto de software embarcado, o que normalmente não é contemplado pela engenharia de software tradicional. / This work proposes a new approach for embedded software development, by combining the abstraction and model verification properties of the Alloy declarative language with the broad acceptance in industry of Java. The approach comes into play since software automation in the embedded domain has become a major need, as currently most of the development time is spent designing software for such hardconstrained resources products. Design automation tools for embedded systems must meet the demand for productivity and maintainability, but constraints such as memory, power and performance must still be considered. Design automation tools deal with productivity and maintainability by allowing high-level specifications, which is hard to accomplish on the embedded domain due to the mixed behavior nature of many embedded applications. Approaches that provide means for formal verification are also attractive, but their usage is usually not straightforward, and for this reason they are not that helpful in dealing with time-tomarket constraints. By using Alloy, based in first-order logic, it is possible to obtain high-level specifications and formal model verification with a single language. This work shows the powerful abstraction provided by the Alloy language for embedded applications, as well as rules for obtaining automatically Java code from Alloy models. The Java source code generation from Alloy models, combined with an estimation tool, provides design space exploration to match tight embedded software design constraints, what is usually not taken into account by standard software engineering techniques.
|
138 |
Polymage : Automatic Optimization for Image Processing PipelinesMullapudi, Ravi Teja January 2015 (has links) (PDF)
Image processing pipelines are ubiquitous. Every image captured by a camera and every image uploaded on social networks like Google+or Facebook is processed by a pipeline. Applications in a wide range of domains like computational photography, computer vision and medical imaging use image processing pipelines. Many of these applications demand high-performance which requires effective utilization of modern architectures. Given the proliferation of camera enabled devices and social networks optimizing these emerging workloads has become important both at the data center and the embedded device scales.
An image processing pipeline can be viewed as a graph of interconnected stages which process images successively. Each stage typically performs one of point-wise, stencil, sam-pling, reduction or data-dependent operations on image pixels. Individual stages in a pipeline typically exhibit abundant data parallelism that can be exploited with relative ease. However, the stages also require high memory bandwidth preventing effective uti-lization of parallelism available on modern architectures. The traditional options are using optimized libraries like OpenCV or to optimize manually. While using libraries precludes optimization across library routines, manual optimization accounting for both parallelism and locality is very tedious.
Inthisthesis,wepresentthedesignandimplementationofPolyMage,adomain-specific language and compiler for image processing pipelines. The focus of the system is on au-tomatically generating high-performance implementations of image processing pipelines expressed in a high-level declarative language. We achieve such automation with:
• tiling techniques to improve parallelism and locality by introducing redundant computation,
v
a model-driven fusion heuristic which enables a trade-off between locality and re-dundant computations, and anautotuner whichleveragesthefusionheuristictoexploreasmallsubsetofpipeline implementations and find the best performing one.
Our optimization approach primarily relies on the transformation and code generation ca-pabilities of the polyhedral compiler framework. To the best of our knowledge, this is the first model-driven compiler for image processing pipelines that performs complex fusion, tiling, and storage optimization fully automatically. We evaluate our framework on a modern multicore system using a set of seven benchmarks which vary widely in structure and complexity. Experimental results show that the performance of pipeline implementations generated by our approach is:
• up to 1.81× better than pipeline implementations manually tuned using Halide, a state-of-the-art language and compiler for image processing pipelines,
• on average 5.39× better than pipeline implementations automatically tuned using Halide and OpenTuner, and
• on average 3.3× better than naive pipeline implementations which only exploit par-allelism without optimizing for locality.
We also demonstrate that the performance of PolyMage generated code is better or compa-rable to implementations using OpenCV, a state-of-the-art image processing and computer vision library.
|
139 |
Um processo dirigido a modelos para geração de códigoPapotti, Paulo Eduardo 17 May 2013 (has links)
Made available in DSpace on 2016-06-02T19:06:04Z (GMT). No. of bitstreams: 1
5180.pdf: 8285938 bytes, checksum: 0110755140178ec91052f03c8f73ca2d (MD5)
Previous issue date: 2013-05-17 / Universidade Federal de Sao Carlos / Software development is an activity in constant change over time. Given the complexity and high cost that exists in software construction, there is high demand, especially in the software industries, for methodologies and tools that enable to increase software productivity by spending less time and effort in its development. Among the challenges that exist in Software Engineering, there is a need in knowing and exploring techniques and tools that enable to increase productivity and maintai software quality. Approaches related to model-driven development can be used as a starting point for modeling and to specify the requirements of a software system. Models provide a representation with higher level of abstraction of system design and assist to understand the system. Through the execution of model-to-code transformation mechanisms, implementation artifacts for different technologies can be generated based on data extracted and interpreted from models. Furthermore, reflexive metaprogramming is a technique that can be used to complement the code generation performed by model-to-code transformations, automating most of tasks of developers, such as CRUD (Create, Retrieve, Update, Delete) functionalities, freeing them to perform more important tasks in development process. Therefore, this research proposes a software process to guide professionals in developing applications using such techniques to accomplish code generation, in order to increase software productivity and facilitate maintenance. / O desenvolvimento de software é uma atividade em constante mudança ao longo do tempo. Diante da complexidade e do alto custo existente na construção de um software, existe uma grande demanda, sobretudo nas indústrias de software, por metodologias e ferramentas que possibilitem aumentar a produtividade de software, gastando menos tempo e esforços em seu desenvolvimento. Dentre os desafios existentes na Engenharia de Software, existe a necessidade de conhecer e explorar diferentes técnicas e ferramentas que viabilizem aumentar a produtividade mantendo a qualidade do software. Abordagens relacionadas ao desenvolvimento dirigido a modelos podem ser utilizadas como ponto de partida para modelar e especificar os requisitos de um sistema de software. Os modelos fornecem uma representação com maior nível de abstração do projeto do sistema e auxiliam na compreensão do sistema. Por meio da aplicação de mecanismos de transformação de modelos em código, é possível gerar código de artefatos de implementação para diferentes tecnologias a partir de dados extraídos e interpretados dos modelos. Além disso, a metaprogramação reflexiva é uma técnica que pode ser empregada para complementar a geração de código realizada por transformações de modelos, automatizando grande parte das tarefas do desenvolvedor, tais como as funcionalidades CRUD (Create, Retrieve, Update, Delete), liberandoo para atuar em outras tarefas mais importantes do processo de desenvolvimento. Dessa forma, este trabalho define um processo de software que visa orientar os profissionais no desenvolvimento de aplicações utilizando tais técnicas para realizar geração código, que tem como objetivo aumentar a produtividade de software e facilitar sua manutenção.
|
140 |
MME-MDD : um método para manutenção e evolução de sistemas baseados no MDDArndt, Bruno Felipe 08 March 2016 (has links)
Submitted by Alison Vanceto (alison-vanceto@hotmail.com) on 2017-02-07T10:21:15Z
No. of bitstreams: 1
DissBFA.pdf: 12687971 bytes, checksum: 19789fb95e5c01987f5067e083d04248 (MD5) / Approved for entry into archive by Camila Passos (camilapassos@ufscar.br) on 2017-02-08T12:04:07Z (GMT) No. of bitstreams: 1
DissBFA.pdf: 12687971 bytes, checksum: 19789fb95e5c01987f5067e083d04248 (MD5) / Approved for entry into archive by Camila Passos (camilapassos@ufscar.br) on 2017-02-08T12:08:22Z (GMT) No. of bitstreams: 1
DissBFA.pdf: 12687971 bytes, checksum: 19789fb95e5c01987f5067e083d04248 (MD5) / Made available in DSpace on 2017-02-08T12:09:45Z (GMT). No. of bitstreams: 1
DissBFA.pdf: 12687971 bytes, checksum: 19789fb95e5c01987f5067e083d04248 (MD5)
Previous issue date: 2016-03-08 / Coordenação de Aperfeiçoamento de Pessoal de Nível Superior (CAPES) / Model-Driven Development (MDD) is proposed to reduce the semantic gap
between problem and solution/implementation domains. Some tools are used, and
the code generator is commonly used in this context. These generators are often
implemented using templates. A Reference Implementation (RI) favoring the development/
maintenance of software facilitates this implementation’s types. However,
RI requires a code migration process which consists in artifacts’ synchronization,
and it is responsible for 20% to 25% of the time spent on development. The literature
has no describe automatic solutions, but the group that this reaserch was
included has develop tools that automate this process and reduce the time spent on
some tasks. But each task has a different performance in relation to time spent, so
automation of some tasks can be disadvantageous. Few reports describe such tasks
and which ones are capable of automatic code migration. The aim of this study is
to investigate the maintain and evolution process to identify and describe the types
of maintain and evolution tasks that are essentially. Based on this study, a method
(MME-MDD) that drives the developer during that proccess to guide the developer
during the realization of each task, with the aim to maximize the benefits of this
approach. The MME-MDD was validated by a case study and a empirical study
and the method showed effective in most of tasks. In addition, studies show that
using the proposed method brought a gain in the quality of the source code. / O MDD (Model-Driven Development) tem como proposta a redução da
distância semântica entre os domínios problema e solução/implementação. Para
isso, são utilizadas algumas ferramentas, sendo o gerador de código comumente
usado neste contexto. Os geradores de código são frequentemente implementados
com a utilização de templates. Para facilitar este tipo de implementação, usualmente
é empregado uma Implementação de Referência (IR), favorecendo a evolução/
manutenção do software. Contudo, a IR traz a necessidade do processo de
migração de código, que consiste na sincronização entre o seu código-fonte e os
templates, sendo que este é responsável por 20 a 25% do tempo gasto no desenvolvimento.
Na literatura não há relatos de solução automatizada, mas o grupo no qual
esta pesquisa se insere vem desenvolvendo ferramentas que automatizam este processo
e reduzem o tempo aplicado em algumas tarefas testadas. Porém, cada tarefa
tem um desempenho diferente em relação ao tempo gasto e, portanto, a automação
de algumas tarefas pode ser desvantajosa. Existem poucos relatos na literatura descrevendo
tais tarefas e quais são os passos necessários para realizá-las. O objetivo
deste estudo foi a investigação do processo de manutenção e evolução de sistemas
baseados em MDD com a finalidade de identificar e descrever os tipos de tarefas
de manutenção e evolução. Com base nesse estudo, foi elaborado o método MMEMDD
que conduz o desenvolvedor durante o processo de manutenção e evolução de
sistemas, visando guiar o desenvolvedor durante a realização de cada um dos tipos
de tarefas, com o intuito de maximizar os benefícios da utilização dessa abordagem.
O método foi validado por meio de um estudo de caso e um estudo experimental,
sendo que o método se mostrou efetivo em grande parte das tarefas testadas. Além
disso, os estudos apontaram que a utilização do método proposto trouxe ganho na
qualidade do código-fonte.
|
Page generated in 0.0749 seconds