To see the other types of publications on this topic, follow the link: Compiladores.
Dissertations / Theses on the topic 'Compiladores'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Compiladores.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Castro, Gabriel de Godoy Corrêa e. "Geração de compiladores baseada em componentes." Universidade Federal de Minas Gerais, 2014. http://hdl.handle.net/1843/ESBF-9P2FVH.
Full textAbstract:
The construction of a compiler of a real size programming language is a complex and big project. So, proper tools are needed to help in this task. However, compiler generation systems are still not popular yet. This is due to the complexity of these systems, complicated by their lack of readability and low reusability of language definitions used by other systems. This dissertation presents a compiler development environment which is focused on the readability of the compiler code, making the environment simpler to use. This environment translates the source code to an abstract syntax tree and performs, subsequently, semantic actions to generate code while visiting the AST generated. The environment is supported by a code generator infrastructure that encapsulates fundamental and recurring concepts of the constructs of imperative programming languages. The infrastructure consists of components of semantic actions, intermediary code instructions and a symbol table. The components are utilized by the programming language implementer to perform the semantic actions necessary to compile the language. The symbol table is used to control the declarations of the variables used in the infrastructure and allows the selection of different strategies for scope control and memory allocation. The environment was validated with an implementation for the compiler of the language Small, defined herein.A construção de um compilador de linguagens de porte real é um projeto grande e de alta complexidade. Dessa forma, são necessárias ferramentas que auxiliem esse processo de construção. Entretanto, os sistemas para a geração completa de um compilador ainda não se tornaram populares devido à sua complexidade de utilização, complicada pela baixa legibilidade de alguns sistemas e baixa reusabilidade de componentes de projetos similares. Este trabalho de dissertação apresenta um ambiente de desenvolvimento de compiladores cujo enfoque está na legibilidade do código de implementação dos tradutores, com o objetivo de tornar o ambiente mais simples de utilizar. Esse ambiente realiza a tradução do código fonte para uma árvore de sintaxe abstrata e realiza, subsequentemente, ações semânticas para geração de código durante o caminhamento da AST gerada. O ambiente é auxiliado por uma infraestrutura de geração de código que encapsula conceitos fundamentais e recorrentes de importantes construções de linguagens de programação imperativas. A infraestrutura é formada por componentes de ações semânticas, instruções de código intermediário e uma tabela de símbolos. Os componentes são utilizados pelo implementador da linguagem de programação para realizar as ações semânticas necessárias para a compilação das construções de sua linguagem. A tabela de símbolos é utilizada para controlar as declarações de variáveis utilizadas na infraestrutura e permite implementar diversas políticas de controle de escopo e alocação de memória. O ambiente foi validado com a implementação do compilador da linguagem Small, aqui definida.
2
Lopes, Joelmir José. "Estudos e avaliações de compiladores para arquiteturas reconfiguráveis." Universidade de São Paulo, 2007. http://www.teses.usp.br/teses/disponiveis/55/55134/tde-13092007-102252/.
Full textAbstract:
Com o aumento crescente das capacidades dos circuitos integrado e conseqüente complexidade das aplicações, em especial as embarcadas, um requisito tem se tornado fundamental no desenvolvimento desses sistemas: ferramentas de desenvolvimento cada vez mais acessíveis aos engenheiros, permitindo, por exemplo, que um programa escrito em linguagem C possa ser convertido diretamente em hardware. Os FPGAs (Field Programmable Gate Array), elemento fundamental na caracterização de computação reconfigurável, é um exemplo desse crescimento, tanto em capacidade do CI como disponibilidade de ferramentas. Esse projeto teve como objetivos: estudar algumas ferramentas de conversão C, C++ ou Java para hardware reconfigurável; estudar benchmarks a serem executadas nessas ferramentas para obter desempenho das mesmas, e ter o domínio dos conceitos na conversão de linguagens de alto nível para hardware reconfigurável. A plataforma utilizada no projeto foi a da empresa Xilinx XUP V2PWith the growing capacities of Integrated Circuits (IC) and the complexity of the applications, especially in embedded systems, there are now requisites for developing tools that convert algorithms C direct into the hardware. As a fundamental element to characterize Reconfigurable Computing, FPGA (Field Programmable Gate Array) is an example of those CIs, as well as the tools that have been developed. In this project we present different tools to convert C into the hardware. We also present benchmarks to be executed on those tools for performance analysis. Finally we conclude the project presenting results relating the experience to implement C direct into the hardware. The Xilinx XUP V2P platform was used in the project
3
Garcia, Lopez Javier. "Implementação de um compilador para software numérico." reponame:Biblioteca Digital de Teses e Dissertações da UFRGS, 1987. http://hdl.handle.net/10183/23433.
Full textAbstract:
Este trabalho apresenta proposta e implementação de uma linguagem de programação orientada para usuárias de aplicações técnicas e matemáticas. São discutidas as características da linguagem desde o ponto de vista da aplicabilidade e da facilidade de utilização. É feito um estudo genérico de como as linguagens mais usadas, para este tipo de usuário, abordam as problemas de manipulação de estruturas numéricas especiais coma Complexos, Intervalos e Matrizes. Esse mesmo estudo mostra como e feita a implementação dos Tipos Abstratos de Dados e os problemas que isto acarreta nessas linguagens . Finalmente é apresentada uma forma de implementar as estruturas numéricas acima, as Tipos Abstratas de Dados e a gerenciador da linguagem, a qual denominamos PASCAL-M.This work presents a proposal and implementation of a programming language oriented to applied mathematics and engineering. The characteristics of the language are discussed from the point of view of both application and utilization aspects. A generic study has been done to find out a wag of implementing numerical structures such as complex numbers, intervals and matrices, as well as abstract data types on several programming languages. Finally, an implementation of numerical and abstract data type structures on Pascal, and a language manager, is presented. The extended language is called Pascal-M.
4
Auler, Rafael 1986. "Geração automática de backend de compiladores baseada em ADLs." [s.n.], 2011. http://repositorio.unicamp.br/jspui/handle/REPOSIP/275728.
Full textAbstract:
Orientador: Paulo Cesar CentoducatteDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-19T09:40:46Z (GMT). No. of bitstreams: 1 Auler_Rafael_M.pdf: 1695289 bytes, checksum: e7a4a8add24fe834544d29e932451d61 (MD5) Previous issue date: 2011
Resumo: O processo de automatização da criação de backends de compiladores, isto é, do componente responsável pela tradução final para código de máquina, é perseguido desde o surgimento dos primeiros compiladores. A separação entre os algoritmos empregados no backend e a descrição formal da máquina, que requer conhecimento sobre a arquitetura alvo, é uma característica bastante desejada, uma vez que propicia a criação de novos backends sem a necessidade de conhecer o projeto do compilador, mas apenas do processador. Por esse motivo, um esforço natural para manter o desenvolvimento simples e intuitivo é a concentração do conhecimento sobre a máquina alvo em uma forma concisa de descrição, a partir da qual seja possível especializar algoritmos genéricos de compilação para este alvo específico. Uma linguagem de descrição de arquiteturas (ADL) permite a especificação das características arquiteturais de processadores, incluindo o seu conjunto de instruções (ISA). Neste trabalho, um estudo de mecanismos para gerar backend de compiladores através de descrições arquiteturais de processadores é apresentado, com ênfase no estudo de caso da ADL ArchC com o compilador LLVM. Um protótipo de um gerador de backends para LLVM a partir de uma descrição em ArchC foi desenvolvido, e backends para as arquiteturas ARM, MIPS, SPARC e PowerPC foram gerados com sucesso. Para alcançar este objetivo, foi usado um algoritmo de busca para resolver o problema da programação automática e inferir como implementar fragmentos pré-selecionados da linguagem intermediária LLVM utilizando instruções de uma arquitetura alvo arbitrária. Quatro técnicas para aumentar a velocidade deste algoritmo são apresentadas, de forma a não somente viabilizar uma solução para a geração automática de backends, mas também concluir o processo em menos de 20 segundos para três das quatro arquiteturas testadas. Programas do benchmark Mibench foram compilados com os compiladores gerados, executados com simuladores ArchC e os resultados comparados com aqueles gerados a partir dos mesmos programas compilados com os compiladores gcc e LLVM original, validando os novos backends. A qualidade do código gerado pode ser comparada com a de compiladores consagrados, caso seja utilizado um otimizador peephole para realizar substituições simples de algumas sequências ineficientes
Abstract: Researchers pursue the automation of compiler backend generation, the component responsible for final translation from intermediate language to machine code, since the begining of compilers theory creation. The separation between the algorithms used in the backend and formal machine description, which encompasses knowledge about the target architecture, is an important feature, since it facilitates the creation of new backends without the need for deep understanding of the compiler project. For this reason, an effort to maintain the development natural, simple and intuitive must concentrate the knowledge of the target machine in a concise description in a way it is possible to specialize generic algorithms to this target. An architecture description language (ADL) allows the specification of architectural features of processors, comprising the instruction set architecture available. This work presents a study of mechanisms for generating compiler backend through architectural descriptions of processors, with emphasis on a case study of the ArchC ADL with the LLVM compiler. We developed an automatic backend generator prototype for LLVM backends based on ArchC and successfully generated backends for the architectures ARM, MIPS, PowerPC and SPARC. To achieve this, we used a search algorithm to solve the problem of automatic programming and to infer how to implement pre-selected fragments of LLVM intermediate language using instructions of an arbitrary target architecture. We present four techniques to increase the speed of this algorithm which not only enables a solution for the automatic generation of backends, but also completes the process in less than 20 seconds for three of four architectures tested. Test compilation of Mibench benchmark programs attested the proper functioning of the backend and revealed that the quality of the generated code can compare with that of existing compilers, if a peephole optimizer were used to perform some simple substitutions of inefficient sequences
Mestrado
Ciência da Computação
Mestre em Ciência da Computação
5
Souza, Marcos Rodrigo Sol. "Eliminação de testes de overflow para compiladores de trilhas." Universidade Federal de Minas Gerais, 2011. http://hdl.handle.net/1843/SLSS-8GPQ97.
Full textAbstract:
Trace compilation is a new technique used by just-in-time (JIT) compilers such as TraceMonkey, the JavaScript engine in the Mozilla Firefox browser. Contrary to traditional JIT machines, a trace compiler works on only part of the source program, normally a linear path inside a heavily executed loop. Because the trace is compiled during the interpretation of the source program the JIT compiler has access to the values manipulated at runtime. This observation gives to the compiler the possibility of producing binary code specialized to these values. In this thesis we explore this opportunity to provide an analysis that removes unnecessary overflow tests from JavaScript programs. Our optimization uses range analysis to show that some operations cannot produce overflows. The analysis is linear in size and space on the number of instructions present in the input trace, and it is more effective than traditional range analyses, because we have access to values known only at execution time. We have implemented our analysis on top of Firefox's TraceMonkey, and have tested it on over 1000 scripts from several industrial strength benchmarks, including the scripts present in the top 100 most visited webpages in the Alexa index. We generate binaries to either x86 or the embedded microprocessor ST40-300. On the average, we eliminate 91.82% of the overflows in the programspresent in the TraceMonkey test suite. This optimization provides an average code size reduction of 8.83% on ST40 and 6.63% on x86. Our optimization increases TraceMonkey's runtime by 2.53%.Compilação de trilhas é uma nova técnica utilizada por compiladores just-in-time (JIT) como o TraceMonkey, o compilador de JavaScript do navegador Mozilla Firefox. Diferente dos compiladores just-in-time tradicionais, um compilador de trilhas trabalha somente com uma parte do programa fonte, geralmente um caminho linear de instruções que são frequentemente executadas dentro de um laço. Como uma trilha é compilada durante a interpretação de um programa, o compilador just-in-time tem acesso aos valores manipulados em tempo de execução. A capacidade de acessar esses valores permite ao compilador a possibilidade de produzir código de máquina mais otimizado. Nesta dissertação é explorada a oportunidade de prover uma análise que remove testes de overflow desnecessários de programas JavaScript. Para mostrar que algumas operações não podem causar overflows é utilizada uma técnica denominada análise de largura de variáveis. A otimização proposta é linear em tamanho e espaço com o número de instruções presentes na trilha de entrada, e é mais efetiva que as análises de largura de variável tradicionais porque utiliza valores conhecidos em tempo de execução. A otimização proposta foi implementada no navegador Mozilla Firefox, e testada em mais de 1.000 programas JavaScript de diversas coleções, incluindo os 100 sítios mais visitados da Internet segundo o índice Alexa. Foram produzidos códigos binários para as arquiteturas x86 e ST40-300. Na média, a otimização proposta foi capaz de remover 91.82% dos testes de overflow nos programas presentes na coleção de programas de teste do TraceMonkey. A otimização proposta prove uma redução do tamanho do código binário de 8.83% na plataforma ST40 e de 6.63% na plataforma x86. A otimização aumenta o tempo de execução do compilador TraceMonkey em 2.53.
6
Matos, Paulo. "Um modelo arquitectónico para desenvolvimento de compiladores: aplicação à framework Dolphin." Doctoral thesis, Universidade do Minho, 2005. http://hdl.handle.net/10198/1518.
Full textAbstract:
A indústria dos microprocessadores é uma área com uma dinâmica ímpar, reconhecida pelo seu avançado estado tecnológico, mas também pela sua constante evolução. Esta dinâmica deve-se em grande parte à pressão que é constantemente exercida no sentido de se obter maior poder computacional. Pressão essa que tem crescido de forma exponencial, e à qual não é alheia a forte expansão da \gloss{web} e o uso generalizado de conteúdos multimédia.
%Note-se por exemplo que a compactação de vídeo em real time só se tornou viável dotando os microprocessadores de instruções específicas para esse fim.
No entanto, esta evolução só é rentabilizada através da utilização de ferramentas adequadas, como é o caso dos compiladores, que por desempenharem um papel fundamental têm forçosamente de acompanhar a evolução dos microprocessadores. É, como tal, exigida uma resposta rápida por parte de quem desenvolve este tipo de ferramentas e a tecnologia que lhes está inerente. Daí que o desenvolvimento de aplicações que visem a construção de compiladores tenha um papel crucial, quer no sentido de tornar mais acessível a realização de uma tarefa que é complexa, quer no sentido de acelerar o processo de desenvolvimento de forma a acompanhar a evolução dos microprocessadores. Objectivos que aliás estão relacionados, dado que este processo será tão mais rápido, quanto mais acessível for a própria construção dos compiladores.
Este trabalho de doutoramento tem assim por objectivo contribuir para simplificar o processo de construção de compiladores. Pretende-se mostrar que a melhor forma de alcançar este objectivo, passa pela utilização de uma abordagem, centrada no nível intermédio do processo de compilação, que tem por base uma framework. No sentido de suportar esta abordagem, propõe-se um modelo para a representação de código, que introduz novos conceitos e funcionalidades, que visam facilitar o desenvolvimento dos componentes e contribuir para que estes sejam mais eficientes.
A grande contribuição deste trabalho de doutoramento é, no entanto, numa arquitectura que estabelece o comportamento e o relacionamento entre os elementos da representação de código e os componentes que sobre estes trabalham. Esta arquitectura, para além de garantir a eficiência do processo de compilação, simplifica a reutilização dos componentes, poupando o utilizador à implementação de vários mecanismos relacionados com a consistência e a gestão de dependências entre componentes
Do trabalho realizado ao longo deste doutoramento, resultou também uma plataforma para desenvolvimento de compiladores, a framework Dolphin, cuja implementação teve por objectivo testar a viabilidade do modelo de representação de código e da arquitectura propostas nesta dissertação. The microprocessors industry is a remarkable, dynamic, and recognized area not only
by its technological progress, but also by its constant evolution. This dynamic is the result
of a systematic pressure to obtain more computational power, which has been raised exponentially
with the expansion of the Web and with the generalization of multimedia contents.
However this evolution can only be profitable with the usage of appropriated tools, like compilers.
They play a fundamental role to take advantage of the whole features supplied by the
microprocessors. As consequence, compilers must follow the evolution of the microprocessors,
and their developers should have an adequate methodological and technological support.
In this context, compiler development tools give an essential contribution, making
the execution of a complex task less difficult, as well as reducing the necessary time to
accomplish it. Notice that both goals are related, a simple construction process, implies a
shorter development time.
In this sense, the goal established for this Ph.D. project is to simplify the compilers
construction process. To achieve this goal, the usage of a data centred approach based on a
framework is proposed, relying upon the two main contributions of this thesis. The first one
is a code representation model that introduces new concepts and features, to simplify the
construction of compiler components and to make them more efficient. The second and main
contribution is an architecture that establishes the behaviour and the relationship between
the code representation elements and the compilers components. This architecture makes the
compilation process more efficient and simplifies the reuse of the components by hiding many
implementation details, namely related with components consistency and dependencies.
Another important outcome of this work is a platform for compilers development, the
Dolphin framework, that was implemented to test and validate the code representation model and the proposed architecture.
7
Wuerges, Emílio. "Um analisador de restrições de tempo real para compiladores redirecionáveis automaticamente." Florianópolis, SC, 2008. http://repositorio.ufsc.br/xmlui/handle/123456789/91975.
Full textAbstract:
Dissertação (mestrado) - Universidade Federal de Santa Catarina, Centro Tecnológico. Programa de Pós-Graduação em Ciência da Computação.Made available in DSpace on 2012-10-24T04:28:13Z (GMT). No. of bitstreams: 1 263131.pdf: 756956 bytes, checksum: 840e0f33f9d99e70d7bddaadf6eaffa6 (MD5)
8
Santos, Marco Aurelio Freitas. "Estudo da utilização de uma ferramenta para construção de programas em português em disciplinas básicas de ensino de programação." reponame:Biblioteca Digital de Teses e Dissertações da UFRGS, 2001. http://hdl.handle.net/10183/4274.
Full textAbstract:
Este trabalho tem por objetivo apresentar e estudar a aplicação de uma ferramenta chamada PCP – Pseudo-Compilador Portugol, criada para auxiliar estudantes de programação a aprimorar o raciocínio lógico e a criar programas estruturados, sem que precisem se preocupar com comandos e instruções em Inglês ou tenham conhecimento de uma linguagem de programação específica. Por ser uma ferramenta que usa somente palavras do nosso idioma, os alunos podem direcionar todo o seu raciocínio no entendimento e resolução do problema em forma de algoritmo. O estudo experimental realizado neste trabalho pretende analisar e comparar o aprendizado entre grupos de alunos de disciplinas de programação utilizando e não utilizando esta ferramenta. Além de acompanhar o desempenho dos alunos, pretende também coletar informações durante as baterias de testes e obter as opiniões dos mesmos em relação ao PCP, no que se refere às facilidades, dificuldades, pontos positivos e falhas apresentadas. Este estudo é apresentado em duas etapas, com oito baterias de teste em cada uma. Na primeira etapa foram selecionados alunos do Curso de Ciência da Computação da UNIGRAN, em Dourados-MS; na segunda etapa foram selecionados alunos da Escola Anglo Decisivo. Estas duas etapas possibilitam a análise do aprendizado proporcionado pela ferramenta com alunos que já têm alguma noção de programação e com alunos que não tiveram nenhum contato com o desenvolvimento de programas.
9
Ferreira, Maria Janaina da Silva. "EMS: um plug-in para exibição de mensagens de erro dos compiladores." Universidade Federal de São Carlos, 2015. https://repositorio.ufscar.br/handle/ufscar/7915.
Full textAbstract:
Submitted by Milena Rubi (milenarubi@ufscar.br) on 2016-10-18T13:50:17Z
No. of bitstreams: 1
FERREIRA_Maria_2015.pdf: 44702801 bytes, checksum: d58773cbbac5f088372d16f186805b06 (MD5)Approved for entry into archive by Milena Rubi (milenarubi@ufscar.br) on 2016-10-18T13:50:31Z (GMT) No. of bitstreams: 1 FERREIRA_Maria_2015.pdf: 44702801 bytes, checksum: d58773cbbac5f088372d16f186805b06 (MD5)
Approved for entry into archive by Milena Rubi (milenarubi@ufscar.br) on 2016-10-18T13:50:43Z (GMT) No. of bitstreams: 1 FERREIRA_Maria_2015.pdf: 44702801 bytes, checksum: d58773cbbac5f088372d16f186805b06 (MD5)
Made available in DSpace on 2016-10-18T13:51:11Z (GMT). No. of bitstreams: 1 FERREIRA_Maria_2015.pdf: 44702801 bytes, checksum: d58773cbbac5f088372d16f186805b06 (MD5) Previous issue date: 2015-12-18
Coordenação de Aperfeiçoamento de Pessoal de Nível Superior (CAPES)
Compiler error messages should allow programmers to understand and solve quickly problems found during the compilation process. However, compilers usually issue short contextless messages with little information and with terms that are difficult to understand. This work introduces the plug-in Error Message System (EMS) that allows the presentation of easy-to-understand and more meaningful error messages. EMS is a plug-in to the Eclipse IDE. It is highly configurable through Domain Specific Languages (DSLs). The DSLs allow that regular users build their own error messages and share them. Beginner programmers can use a set of error messages adapted to them thus reducing the time of understanding and correction of compilation errors.
As mensagens de erro dos compiladores devem permitir que os programadores compreendam e solucionem os problemas encontrados durante o processo de compilação rapidamente. Entretanto, os compiladores usualmente emitem mensagens curtas, sem contexto, pouco informativas e com termos de difícil compreensão. Este trabalho apresenta o plug-in Error Message System (EMS) que permite a apresentação das mensagens de erro mais fáceis de entender e mais informativas. EMS é um plugin para a IDE Eclipe e é altamente configurável através de linguagens específicas de domínio(LED). As LEDs permitem que usuários comuns façam suas próprias mensagens de erro e as compartilhem. Programadores iniciantes podem utilizar um conjunto de mensagens adaptadas a eles, reduzindo o tempo de compreensão e correção dos erros de compilação.
10
Mignon, Alexandre dos Santos. "ML4JIT- um arcabouço para pesquisa com aprendizado de máquina em compiladores JIT." Universidade de São Paulo, 2017. http://www.teses.usp.br/teses/disponiveis/3/3141/tde-05092017-101617/.
Full textAbstract:
Determinar o melhor conjunto de otimizações para serem aplicadas a um programa tem sido o foco de pesquisas em otimização de compilação por décadas. Em geral, o conjunto de otimizações é definido manualmente pelos desenvolvedores do compilador e aplicado a todos os programas. Técnicas de aprendizado de máquina supervisionado têm sido usadas para o desenvolvimento de heurísticas de otimização de código. Elas pretendem determinar o melhor conjunto de otimizações com o mínimo de interferência humana. Este trabalho apresenta o ML4JIT, um arcabouço para pesquisa com aprendizado de máquina em compiladores JIT para a linguagem Java. O arcabouço permite que sejam realizadas pesquisas para encontrar uma melhor sintonia das otimizações específica para cada método de um programa. Experimentos foram realizados para a validação do arcabouço com o objetivo de verificar se com seu uso houve uma redução no tempo de compilação dos métodos e também no tempo de execução do programa.Determining the best set of optimizations to be applied in a program has been the focus of research on compile optimization for decades. In general, the set of optimization is manually defined by compiler developers and apply to all programs. Supervised machine learning techniques have been used for the development of code optimization heuristics. They intend to determine the best set of optimization with minimal human intervention. This work presents the ML4JIT, a framework for research with machine learning in JIT compilers for Java language. The framework allows research to be performed to better tune the optimizations specific to each method of a program. Experiments were performed for the validation of the framework with the objective of verifying if its use had a reduction in the compilation time of the methods and also in the execution time of the program.
11
Sousa, Antonio Heronaldo de. "ONAGRO : um ambiente grafico para desenvolvimento de software para microcontroladores." [s.n.], 1995. http://repositorio.unicamp.br/jspui/handle/REPOSIP/258986.
Full textAbstract:
Orientador: Elnathan Chagas FerreiraDissertação (mestrado) - Universidade Estadual de Campinas, Faculdade de Engenharia Eletrica
Made available in DSpace on 2018-07-20T19:53:26Z (GMT). No. of bitstreams: 1 Sousa_AntonioHeronaldode_M.pdf: 6755137 bytes, checksum: c0c534a5d717e88561ed87d82d76898f (MD5) Previous issue date: 1995
Resumo: o ONAGROéum sistema tradutor que reconhece uma linguagem gráfica de descrição de algoritmos e possibilita a geração de código em Assembly para microcontroladores. Além do tradutor propriamente dito, ele incorpora um editor gráfico para a entrada do programa-fonte, que se assemelha a um algoritmo descrito em linguagem de fluxogramas. Ele também possui um editor de identificadores que permite a descrição dos símbolos identificadores usados no programa. O sistema ONAGRO opera em ambiente Microsoft Windows, oferecendo uma interface amigável com o usuário. Esta interface baseia-se em estruturas gráficas: ícones, janelas, menus e diálogos que o usuário pode ativar através da utilização do mal/se ou, se preferir, do próprio teclado. O sistema foi desenvolvido para trabalhar em computadores compatíveis com o IBM-PC AT e foi implementado em linguagem Visual C++, usando metodologia orientada ao objeto. Diferentemente dos compiladores tradicionais, ele interage com o usuário através de diálogos logo na entrada das instruções, a fim de diminuir erros posteriores de compilação. Além disso, o ONAGRO permite uma maior rapidez na entrada do programa, pois ele é orientado a ícones e não a textos, como nas linguagens convencionais. A programação em ONAGRO é feita com um elevado nível de abstração dos detalhes de hardware. Entretanto, há mecanismos disponíveis para total controle das características fisicas das aplicações. Os testes realizados mostraram que o ambiente proposto é bastante intuitivo e amigável. A documentação dos programas é feita em tempo-real, visto que o próprio programa-fonte se constitui em uma ótima ferramenta de inspeção. Outro aspecto importante, observado nos testes, foi que o código gerado se mostrou relativamente compacto
Abstract: ONAGRO is a translation system that recognizes an algorithm description graphical language and allows the code generation in Assembly for microcontrollers. Besides, it incorporates a graphic editor for the source-program input that is similar to an algorithm described in flowchart language. ONAGRO has also an identifier editor that allows the identifier symboldescription used on the programo ONAGRO is a fully Microsoft Windows compatible software offering a friendly interface with user. This interface is based on graphical structures: icons, windows, menus and dialogues that the user might activate through the mouse or, if he wishes, through the keyboard. ONAGRO was developed to work on IBM-PC AT compatible computers. It was implementedin Visual C++ language by using object oriented methodology. Differently from the traditional compilers, it interacts with the user through the dialogues immediately in the instructions input to reduce later compiler errors. Besides, ONAGRO allows a major quickness in the program input since it is icon oriented and not text oriented like in the conventional languages. The ONAGRO programming is made with high level abstraction of the hardware details. However, there are available mechanisms for full control of physical characteristics applications. The accomplished tests showed that the proposed environment is very intuitive and friendly. The program documentation is made in real-time since the proper source-program is a good inspection too1. Another important aspect observed in the tests was that the generated code proved to be relatively compact
Mestrado
Mestre em Engenharia Elétrica
12
Buss, Marcio de Oliveira. "Escalonamento de instruções em arquiteturas VLIW particionadas explorando Bypassing de operandos." [s.n.], 2001. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276498.
Full textAbstract:
Orientador : Guido Costa Souza de Araujo, Paulo Cesar CentoducatteDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-07-31T15:05:26Z (GMT). No. of bitstreams: 1 Buss_MarciodeOliveira_M.pdf: 6143829 bytes, checksum: 232f545e77eff7126860d60f0be8372a (MD5) Previous issue date: 2001
Resumo: A incansável busca por máquinas mais velozes, aliada aos enormes avanços tecnológicos na concepção de circuitos integrados, retiraram as arquiteturas Very Long Instruction W ord (VLIW) de um estado amórfico para a realidade. Embora tenham surgido como CIs recentemente [1], as máquinas VLIW foram idealizadas há algumas décadas atrás [13, 16, 22, 23]. Os processadores que definem este modelo de processamento não mais obedecem regras clássicas de execução: instruções de um dos possíveis fluxos de controle de um comando de desvio condicional são executadas mesmo antes do término da avaliação da condição, a qual determinará se a transferência de controle deverá ocorrer ou não; executam simultaneamente inúmeras instruções, de diferentes tipos, oriundas do mesmo programa; computam programas que foram compilados de uma forma revolucionária: todo o programa é analisado em busca de operações paralelizáveis, como se fosse um único (macro) bloco. Numa tentativa de contribuição a esta linha de pesquisa, este trabalho visa a detecção e exploração do paralelismo 'escondido' em programas originalmente sequenciais. Esta busca gera resultados que são analisados e quantificados com o intuito de se encontrar uma arquitetura-alvo adequada para uma aplicação específica. Esta metodologia encontra-se inserida no contexto de uma área denominada Embedded Systems, a qual se preocupa em otimizar ao máximo a execução de uma classe restrita de aplicações ou até mesmo uma única aplicação-chave de um sistema dedicado. O modelo de arquitetura considerado neste trabalho é denominado VLIW particionado (do inglês partitioned VLIW). Este modelo difere da máquina VLIW ideal pelo fato de não possuir um único banco de registradores centralizado, mas sim vários bancos de registradores que se comunicam através de barramentos especiais. Com este modelo de arquitetura em mãos, o trabalho desenvolvido nesta dissertação trata da investigação de problemas relacionados com o mapeamento de uma aplicação específica a uma máquina VLIW dedicada. Em um macro-cenário, este trabalho tenta responder a seguinte questão: "Qual é a máquina VLIW adequada para uma dada aplicação ?,'. Ou ainda, "Quantos bancos de registradores e quantas unidades funcionais o processador para esta aplicação deveria ter?"
Abstract: The untiring search for faster machines, alIied to the great technological advances in the field of integrated circuits conception, brought out the Very Long Instruction Word architectures from an amorphous status to reality. Although they have appeared recently as real chips [1], the VLIW machines were idealized some decades ago [13, 16, 22, 23]. The microprocessors that define this processing model no longer obey classical rules of execution: instructions coming from one of the possible control flows resulted of a branch instruction are executed even before the finish of the evaluation condition. This evaluation condition will determine if the control transfer should occur or noto Also, these architectures execute simultaneously many instructions, of different kinds, issued from the same programo Moreover, these processors compute programs that were compiled through a revolutionary way: alI the program is analized to search for paralelizable operations. As an attempt to contribute to this research field, this work aim the development of a methodology to detect and exploit the paralelism "hided" in sequential-written programs. The results generated by this search are analized and quantified in order to find a targetarchitecture for a specific application. This work is inserted in the context of an area calIed Embedded Systems. This research field worry about the maximum optimization of an application class or even only one key-application of a embedded system. The architecture model considered in this work is denoted as "Partitioned VLIW Architecture". This model is slightly different of the ideal VLIW architecture model. In the ideal model, there must be only one centralized register file, in order to guarantee the maximum Instruction Levei ParalIelism (ILP). AlI the functional units share the same register file. On the other hand, the architecture model being considered here presents many distributed register files, which have an special bus to communicate data among them. With this architecture model in mind, the work developed in this thesis investigates some of the problems related to mapping one specific application to an embedded VLIW architecture. Roughly speaking, this work tries to answer the following question: "What is the ideal VLIW architecture for a given application'1" or "How many register files and how many functional units the processor for that application should have '1"
Mestrado
Mestre em Ciência da Computação
13
Berolatti, Gonzales Diego. "Construcción de un compilador de asertos de programación metódica." Bachelor's thesis, Pontificia Universidad Católica del Perú, 2014. http://tesis.pucp.edu.pe/repositorio/handle/123456789/5724.
Full textAbstract:
Siempre ha existido la necesidad de validar la codificación de un programa.
Este proyecto tiene como objetivo la implementación de un compilador que,
mediante notaciones matemáticas que especifican un programa, genere las
instrucciones de manera automática. El resultado tiene como principal
característica que es formalmente correcto. Esto se da debido a que el
compilador implementa una metodología llamada derivación de programas la
cual garantiza esa característica. La implementación de esta metodología se
da mediante la estructura formal de un compilador y la inclusión de un
autómata adaptativo capaz de aplicar las reglas de programación metódica.
El proyecto tiene como alcance el no aplicar ninguna regla que implique
resolver un problema de complejidad np. Debido a esto la expresividad del
lenguaje y su capacidad de generación automática se encuentra limitada. El
resultado es un compilador capaz de generar código de manera automática
en base a las especificaciones que el compilador es capaz de compilar. Este
proyecto es la base de los compiladores de programación automática.Tesis
14
Carneiro, Luiz Carlos Durso. "Compilação de linguagens de comando de alto nivel." [s.n.], 1989. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276014.
Full textAbstract:
Orientador: Rogerio DrummondDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Matematica, Estatistica e Ciencia da Computação
Made available in DSpace on 2018-07-14T12:25:20Z (GMT). No. of bitstreams: 1 Carneiro_LuizCarlosDurso_M.pdf: 1312947 bytes, checksum: acb50ddd9e5a376a4ae9e62164ad20dd (MD5) Previous issue date: 1989
Resumo: É objetivo deste trabalho a apresentação do estudo da viabilidade de implementação de compiladores para linguagens de comando de alto nível. As linguagens de comando têm se mostrado poderosas ferramentas de desenvolvimento nos ambientes de programação modernos, deixando para trás o conceito antigo de que serviam apenas para alocação de periféricos e execução de programas. Este estudo foi iniciado com o intuito de aumentar o potencial destas linguagens, tornando-as mais rápidas. Este trabalho está orga.nizado em 4 capítulos, onde são expostos vários aspectos do estudo das linguagens de comando e da implementação de um compilador protótipo. No capítulo 1 é feita uma introdução às linguagens de comando, abordando tópicos que vão desde a sua origem até as modernas linguagens de comando de alto nível. o capítulo 2 se constitui da apresentação da linguagem de comando escolhida como protótipo para implementação: a C-SHELL do sistema UNIX. Já o capítulo 3 contém informações mais específicas sobre a implementação. Serão mostradas de modo distinto as partes da C-SHELL que foram implementadas utilizando recursos presentes no sistema UNIX e as partes independentes de sistema operacional. Estas discussões serão apresentadas a nível de algoritmos utilizados e quando for necessário, por questões de clareza, serão apresentados detalhes do código gerado. Finalizando, o capítulo 4 é formado pela conclusão deste trabalho. Neste capítulo são discutidas as vantagens da compilação das linguagens de comando de alto nível. Serão apresentados algumas comparações com as linguagens de comando disponíveis no nosso ambiente de programação UNIX e os novos passos a serem tomados nesta linha de estudo. Nos apêndices poderão ser encontradas demonstrações de uso da linguagem, detalhes da composição dos diversos módulos do sistema e orientações para a instalação do compilador em outros sistemas UNIX e UNIX-LIKE.
Abstract: Not informed.
Mestrado
Mestre em Ciência da Computação
15
Costa, Clevan Ricardo da. "Otimização de tipos em linguagem LL." [s.n.], 1995. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276025.
Full textAbstract:
Orientador: Tomasz KowaltowskiDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Matematica, Estatistica e Ciencia da Computação
Made available in DSpace on 2018-07-21T03:22:30Z (GMT). No. of bitstreams: 1 Costa_ClevanRicardoda_M.pdf: 1291094 bytes, checksum: 09ecb271fba38a234b38746d0b88988d (MD5) Previous issue date: 1995
Resumo: Este trabalho consiste na introdução de uma fase de otimização no compilador para a linguagem LL. O eu principal objetivo é a inferência de tipos, realizada através de uma análise de fluxo de dados. São apresentados diversos métodos para inferência de tipos em linguagens orientadas a objetos, bem como uma revisão sobre análise de fluxo de dados. O método de Kaplan e Ullman éapresentado com mais detalhes, juntamente com sua adaptação para LL , sua implementação e junção ao compilador desenvolvido para a linguagem. Finalmente são apresentadas as conclusões, os resultados obtidos e as propostas de extensões futuras para o trabalho.
Abstract: We describe in this thesis an optirnization phase for a compiler for the language LL. Its main goal is type inference achieved through data fiow analysis. Several methods for type inference in object-oriented languages are described, including a description of data fiow analysis. The Kaplan and Ullman method is described in more detail. Its adaptation to . LL and the implementation within an existing compiler are also described. We present also some final conclusions, including examples and possible extensions.
Mestrado
Mestre em Ciência da Computação
16
Maciel, Frederico Buchholz. "Um ambiente para re-estruturação e compilação de programas para máquinas paralelas." Instituto Tecnológico de Aeronáutica, 1990. http://www.bd.bibl.ita.br/tde_busca/arquivo.php?codArquivo=1510.
Full textAbstract:
Diversas pesquisas estudam ambientes de programação que auxiliem os usuários de máquinas paralelas a re-estruturarem seus programas, obtendo com isso uma melhor paralelização e um maior desempenho de execução. Os ambientes existentes ainda abordam poucos aspectos da re-estruturação e atendem apenas a classes particulares de usuários. Este trabalho consiste na concepção de um ambiente de programação paralela que permita atender às necessidades de re-estruturação de usuários de características dispares. Para isto são feitos inicialmente estudos das características dos usuários de máquinas paralelas e dos ambientes existentes, nos quais é mostrada a necessidade de ferramentas, recursos e formas de operação. Estas necessidades são relacionadas entre si, tendo como resultado a estrutura do ambiente e aos sues modos básicos de operação. A seguir é mostrada a implementação da proposta através da expansão de um ambiente existente. É mostrado também um compilador Fortran em implementação que é parte do ambiente proposto.
17
Matos, Paulo. "Estudo e desenvolvimento de sistemas de geração de back-ends do processo de compilação." Master's thesis, Universidade do Minho, 1999. http://hdl.handle.net/10198/1517.
Full textAbstract:
O back-end de um compilador agrupa todo um conjunto de tarefas cuja implementação é intrinsecamente dependente das características do processador para o qual se pretende gerar código. A rápida evolução da industria dos processadores e microcontroladores levou esta área de desenvolvimento de software a realizar fortes investimentos na pesquisa de meios que permitissem dar uma resposta rápida e de qualidade à procura verificada.
É dentro deste contexto que surge o tema e o trabalho desenvolvido ao longo desta tese de mestrado, que pretende de alguma forma sintetizar o que já se encontra feito e propor algumas soluções, que apesar de individualmente não serem originais permitem, quando em conjunto, vislumbrar alternativas aos sistemas já concebidos e avançar um pouco mais na área de investigação dos geradores de código final e optimizadores.
O trabalho aqui descrito é extremamente abrangente para uma qualquer tese, cobrindo todas as áreas do processo de compilação a partir da análise semântica até à geração do código máquina, passando pela apresentação de modelos de compiladores, representação da informação, sistemas de análise de fluxo de controlo e de dados, alocação de registos local e global, selecção de instruções e geração de selectores, optimização de código a vários níveis, etc.
É ainda de referir que do trabalho desenvolvido resultou o Back-End Development System, que como o nome indica é um sistema de apoio ao desenvolvimento das tarefas de back-end de um compilador. The back-end of a compiler gathers a group of tasks, whose implementation is
directly dependent on the features of the processor for which machine code is intended
to be generated. The fast evolution of processors and micro-controllers industry lead
this area of software development to perform strong investments in the research of
means, which would give a fast and proper answer to the demand.
It is within this context that the theme and the work carried on through this thesis
emerges. The aim of this work is to synthesise what has already been done and to give
some solutions which, although individually not original, when put together, they allow
alternatives to the pre-established systems and move on a little further in the research of
generators of final code and optimisers.
This work is extremely wide-ranging, covering all areas of the compiling process,
going from the semantic analyses till the generation of machine code. It also contains
the presentation of models of compilers, representation of information, control and data
flow analysis, local and global registers allocation, instructions selection and generation
of selectors, code optimisation at several levels, etc.
It is also important to refer that from the development work emerged the Back-End
Development System, which, as the name itself indicates, is a software system to
support development of back-end tasks of a compiler.
18
AVELINO, Guilherme Amaral. "Integração de linguagens funcionais à plataforma .NET utilizando o framework Phoenix." Universidade Federal de Pernambuco, 2008. https://repositorio.ufpe.br/handle/123456789/1617.
Full textAbstract:
Made available in DSpace on 2014-06-12T15:51:31Z (GMT). No. of bitstreams: 1
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2008Linguagens funcionais se destacam pelo seu alto poder de expressão e abstração, promovido por construções de alto nível como polimorfismo paramétrico, funções de alto nível e aplicações parciais. Embora estes recursos sejam bastante úteis, tradicionalmente, linguagens funcionais têm sido pouco empregadas fora do ambiente acadêmico. Esta situação é em parte explicada pela ausência de uma infra-estrutura de desenvolvimento que forneça ferramentas e APIs capazes de aumentar a produtividade e permita o uso das mais recentes tecnologias. Uma alternativa para fornecer esta infra-estrutura é integrar linguagens funcionais a plataformas que disponibilizem tais facilidades, como a .NET. Embora a plataforma .NET tenha sido projetada de forma a suportar múltiplas linguagens, seu foco foi dado ao suporte dos paradigmas imperativo e orientado a objeto, carecendo de estruturas que permitam um mapeamento direto de linguagens funcionais. Objetivando estudar novas técnicas de mapeamento de estruturas funcionais na plataforma .NET, neste trabalho foi desenvolvido um compilador funcional que gera código .NET, utilizando o framework Phoenix. O uso do framework Phoenix além de auxiliar na geração inicial do código permitiu que análises e otimizações fossem feitas, posteriormente, melhorando o desempenho dos programas gerados
19
Attrot, Wesley. "Xingo : compilação para uma representação intermediaria executavel." [s.n.], 2004. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276401.
Full textAbstract:
Orientador: Guido Costa Souza de AraujoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-03T21:43:33Z (GMT). No. of bitstreams: 1 Attrot_Wesley_M.pdf: 721177 bytes, checksum: 1c97565911cb6bc949136fe53ed46d5d (MD5) Previous issue date: 2004
Resumo: O aumento da complexidade dos novos projetos de microprocessadores aumentou consideravelmente a necessidade de compiladores que sejam capazes de gerar codigo altamente otimizado. Isto resultou em uma grande demanda por novas otimizações de codigo que possam fazer uso dos novos recursos da arquitetura do processador. Projetar tais otimizações e um trabalho muito complexo que requer uma plataforma de compilação flexivel e simples de usar. O compilador Xingo foi desenvolvido como uma ferramenta para auxiliar o trabalho de pesquisa em areas como otimização de codigo e arquitetura de computadores. Xingo e um compilador otimizante capaz de gerar codigo C a partir de sua representação intermediaria. Tal caracteristica auxilia o desenvolvedor a avaliar a corretude e o desempenho de novas otimizações de codigo. Xingo tambem e um compilador redirecionavel, isto e, pode ser facilmente portado para varias arquiteturas. O compilador Xingo possui oito otimizações independentes de maquina (meados de mar¸co de 2004) e que foram avaliadas com a ajuda do benchmark NullStone, o qual e um benchmark para compiladores de produção de alta qualidade, amplamente utilizado por companias da industria da computação. Do total de 6611 testes realizados pelo NullStone, o Xingo produziu codigo correto para 6581 (99,54%) sem a aplicaçao de nenhuma otimização. Depois da aplicação de todas as otimizações disponiveis, o Xingo produziu codigo correto para 6497 testes (98,27%). Estes numeros refletem a qualidade da plataforma de compilação Xingo, abrindo uma nova gama de oportunidades de pesquisa nas 'areas de tecnologias de compila¸c¿ao e projeto de arquiteturas no Laboratorio de Sistemas de Computação (IC-UNICAMP). Pretende-se tornar o Xingo de dominio publico em meados de 2005
Abstract: The increasing complexity of the new microprocessor designs has considerably increased the pressure for compilers that are capable of generating highly optimized code. This has resulted in a great demand for new code optimizations which can make an effective usage of the processor architectural resources. Designing such optimnizations is usually a very complex task that requires a flexible and easy to use compiler platform. The Xing'o compiler was designed as a tool to help researchers working in areas like compiling optimization and computer architecture. Xing'o is an optimizing compiler capable of generating compilable C code from its intermediate representation. Such feature considerably helps the designer in evaluating the correcteness and performance of new code optimization techniques. Xingo is also a retargetable compiler, that is, it can be easily ported for several architectures. The Xingo compiler has eight machine independent code optimizations (circa March 2004) and was evaluated with the help of the NullStone benchmark, a roduction-quality compiler benchmark, largely used by companies in the computer industry. Out of the 6611 programs available at Nullstone, Xing'o produced correct code for 6581 (99,54%) without the application of any optimization. After applying all the available optimizations, Xingo produced correct code for 6497 programs (98,27%). These numbers reflect the quality of the Xing'o compiling platform, opening up a new set of research opportunities in areas like compiling technology and architecture design at the Computer Systems Laboratory, (IC-UNICAMP). Xingo is planned to go on public domain by early 2005
Mestrado
Ciência da Computação
Mestre em Ciência da Computação
20
Rebelo, Miguel Alexandre Figueira. "Optimizações guiadas por dados reais em linguagens de domínio específico para a web." Master's thesis, Faculdade de Ciências e Tecnologia, 2011. http://hdl.handle.net/10362/6571.
Full textAbstract:
Dissertação apresentada na Faculdade de Ciências e Tecnologia da Universidade Nova de Lisboa para a obtenção do Grau de Mestre em Engenharia InformáticaA utilização de linguagens para domínios específicos tendo em vista um processo de desenvolvimento mais simples e eficiente é um padrão cada vez mais frequente no desenvolvimento de aplicações para a web. Apesar destas linguagens permitirem aos programadores direccionarem o foco de desenvolvimento para as funcionalidades das suas aplicações, estas tendem em produzir aplicações pouco cuidadas a nível do consumo de recursos críticos, limitando a escalabilidade das mesmas. A forma típica de endereçar estas limitações passa por, após o desenvolvimento das suas aplicações, os programadores submeterem as mesmas a testes de desempenho e de carga recorrendo a ferramentas que lhes permitem simular ambientes de utilização reais. Contudo, simular um ambiente idêntico ao que será posteriormente encontrado em produção é um desafio que requer um investimento muito significativo em tempo, competências e atenção por parte da equipa de desenvolvimento, competindo por isso por recursos já escassos no seio de uma organização não dedicada ao desenvolvimento web. Isto leva a que normalmente os programadores apenas consigam identificar os problemas das suas aplicações quando estas, já em execução, começam a falhar. Um dos pontos críticos mais frequentes encontrados em aplicações web é a centralização dos dados em bases de dados, sendo criada uma grande carga sobre o servidor que mantém esses dados. Esta dissertação apresenta uma solução de baixo custo e com ganhos significativos que permite, através da análise de dados reais recolhidos durante a execução das aplicações, guiar os compiladores e os programadores a identificarem as entidades dos modelos de dados das aplicações cujos acessos podem ou devem ser optimizados através de mecanismos de cache. Com esta solução disponibilizámos aos programadores um método fácil e eficiente de identificarem as entidades candidatas à utilização de cache e introduzirem tais optimizações através de mecanismos simples. O risco associado à introdução de cache com a nossa solução é muito baixo, pois foi criado um mecanismo de invalidação que permite que os dados mantidos em cache sejam invalidados sempre que os dados que estes dependem sofram alterações na base de dados. A nossa solução foi implementada e testada sobre um exemplo concreto de uma DSL de alto nível, desenvolvida pela empresa OutSystems, donde se obtiveram resultados que indicam ganhos significativos no desempenho das aplicações finais, melhorando assim a experiência dos utilizadores finais dessas aplicações. Um dos principais objectivos desta solução era diminuir a carga existente sobre o servidor de bases de dados. Este objectivo foi sucedido, tendo sido obtida uma diminuição de pedidos sobre o servidor de base de dados de cerca de 60%(teste realizado em ambiente simulado).
21
Carvalho, Susi Meire Fátima. "Concepção de ambiente computacional para extração de informações dos registros de chamadas telefônicas aplicando técnicas de compilação." Florianópolis, SC, 2002. http://repositorio.ufsc.br/xmlui/handle/123456789/83697.
Full textAbstract:
Dissertação (mestrado) - Universidade Federal de Santa Catarina, Centro Tecnológico. Programa de Pós-Graduação em Ciência da Computação.Made available in DSpace on 2012-10-20T02:29:47Z (GMT). No. of bitstreams: 1 187559.pdf: 1326329 bytes, checksum: ce19b086716ef0ed401625c845169a37 (MD5)
Na busca por informações que auxiliem os processos de gerência da rede, do serviço e, inclusive, do relacionamento com o cliente, o registro da chamada telefônica, também conhecido como CDR (call detail recording), tem ganhado espaço. Mas, em virtude da imensa quantidade de CDRs gerados, bem como da diversidade de formatos existentes, a extração de informações do CDR não é uma tarefa muito fácil, principalmente por quem não possui conhecimentos aprofundados em linguagens de programação. Este trabalho propõe uma linguagem simples para a edição das regras de extração de informações do CDR e um ambiente computacional com interface web que permite a inserção de novos formatos e o cruzamento destas informações com outras (como lista telefônica, cadastros etc.). Visando facilitar a extração destas informações por profissionais de diversas áreas e sua utilização por várias aplicações, o ambiente e a linguagem propostos baseiam-se na teoria de compiladores. Através do uso de um editor dirigido pela sintaxe, que guia o usuário na edição da regra, garante-se sua corretude. Este editor é acompanhado de um tradutor desta regra, para linguagem C++, que é então executada gerando uma saída em arquivo texto ou XML (eXtensible Markup Language). Um caso de aplicação em CRM (Customer Relationship Management) é utilizado para validar a linguagem e o ambiente.
22
Fargasch, Natalia Viana. "Geração e vetorização de instruções de multiplicação e acumulação para processadores DSP SIMD." [s.n.], 2000. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276501.
Full textAbstract:
Orientador : Guido Costa Souza de AraujoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-07-27T21:58:37Z (GMT). No. of bitstreams: 1 Fargasch_NataliaViana_M.pdf: 3686476 bytes, checksum: 309fba7a4a0c16dcd92d2ef76510d72b (MD5) Previous issue date: 2000
Resumo: Processadores que são projetados para executar aplicações específicas - em oposição a processadores de propósito geral- representam uma porcentagem cada vez maior do total de processadores vendidos anualmente. Esses processadores são utilizados em aparelhos eletrônicos como telefones celulares e câmeras digitais, dispositivos médicos de monitoração, modems, sistemas militares de radar, componentes eletrônicos de automóveis, set-top boxes, etc. As aplicações que são executadas por esses processadores tipicamente demandam um alto desempenho, combinado com reduzido tamanho de código e dissipação de energia. Esta dissertação aborda um dos problemas presentes durante a geração de código para uma classe desses processadores, os processadores de sinais digitais (DSPs): como o compilador pode utilizar as instruções especializadas desses processadores a fim de aumentar a densidade e melhorar o desempenho do código gerado. É proposto um procedimento que permite a detecçãoj geração de instruções de multiplicação e acumulação (muito comuns nas aplicações desses processadores). É ainda apresentado um método que permite explorar a possibilidade de execução de código em paralelo por duas ou mais unidades funcionais quando essas são capazes de operar simultaneamente sobre diferentes dados. Os métodos aqui apresentados permitem uma exploração bastante agressiva das instruções de multiplicação e acumulação, e se utilizam de algoritmos de análise de fluxo de dados e técnicas de reestruturação de laços. Não é conhecido nenhum trabalho que aborde esse problema da maneira como é apresentada neste
Abstract: Application specific processors - as opposed to general purpose processors - account for an ever increasing percentage of the processors sold each year. These processors are widely used in electronic devices such as cellular phones and digital cameras, medical monitoring devices, modems, military radar systems, electronic components in vehicles and set-top boxes, to name a few. The applications that usually run on these processors demand high performance, reduced code size and low power consuption. This thesis addresses one of the issues that arise when generating code for a class of these processors, the digital signal processors (DSPs): how the compiler can take advantage of their specialized instructions in order to reduce the size and improve performance of the code generated. A method is proposed that allows for the detectionj generation of multiply and accumulate instructions (typically present in these processors' applications). AIso presented in this work is a method that makes it possible to explore the possibility of running code in parallel on two or more functional units when these are capable of operating simultaneously on different data. The methods herein presented allow for an aggressive harnessing of multiply and accumulate instructions; to accomplish this goal they rely on data flow analysis algorithms and on loop restructuring techniques. No other work is known of that addresses this problem the way it is dealt with in this thesis
Mestrado
Mestre em Ciência da Computação
23
Menotti, Ricardo. "LALP: uma linguagem para exploração do paralelismo de loops em computação reconfigurável." Universidade de São Paulo, 2010. http://www.teses.usp.br/teses/disponiveis/55/55134/tde-17082010-151100/.
Full textAbstract:
A computação reconfigurável tem se tornado cada vez mais importante em sistemas computacionais embarcados e de alto desempenho. Ela permite níveis de desempenho próximos aos obtidos com circuitos integrados de aplicação específica (ASIC), enquanto ainda mantém flexibilidade de projeto e implementação. No entanto, para programar eficientemente os dispositivos, é necessária experiência em desenvolvimento e domínio de linguagem de descrição de hardware (HDL), tais como VHDL ou Verilog. As técnicas empregadas na compilação em alto nível (por exemplo, a partir de programas em C) ainda possuem muitos pontos em aberto a serem resolvidos antes que se possa obter resultados eficientes. Muitos esforços em se obter um mapeamento direto de algoritmos em hardware se concentram em loops, uma vez que eles representam as regiões computacionalmente mais intensivas de muitos programas. Uma técnica particularmente útil para isto é a de loop pipelining, a qual geralmente é adaptada de técnicas de software pipelining. A aplicação dessas técnicas está fortemente relacionada ao escalonamento das instruções, o que frequentemente impede o uso otimizado dos recursos presentes nos FPGAs modernos. Esta tese descreve uma abordagem alternativa para o mapeamento direto de loops descritos em uma linguagem de alto nível para FPGAs. Diferentemente de outras abordagens, esta técnica não é proveniente das técnicas de software pipelining. Nas arquiteturas obtidas o controle das operações é distribuído, tornando desnecessária uma máquina de estados finitos para controlar a ordem das operações, o que permitiu a obtenção de implementações eficientes. A especificação de um bloco de hardware é feita por meio de uma linguagem de domínio específico (LALP), especialmente concebida para suportar a aplicação das técnicas. Embora a sintaxe da linguagem lembre C, ela contém certas construções que permitem intervenções do programador para garantir ou relaxar dependências de dados, conforme necessário, e assim otimizar o desempenho do hardware geradoReconfigurable computing is becoming increasingly important in embedded and high-performance computing systems. It allows performance levels close to the ones obtained with Application-Specific Integrated circuits (ASIC), while still keeping design and implementation flexibility. However, to efficiently program devices, one needs the expertise of hardware developers in order master hardware description languages (HDL) such as VHDL or Verilog. Attempts to furnish a high-level compilation flow (e.g., from C programs) still have to address open issues before broader efficient results can be obtained. Many efforts trying to achieve a direct of algorithms into hardware concentrate on loops since they represent the most computationally intensive regions of many application codes. A particularly useful technique for this purpose is loop pipelining, which is usually adapted from software pipelining techniques. The application of this technique is strongly related to instruction scheduling, whic often prevents an optimized use of the resources present in modern FPGAs. This thesis decribes an alternative approach to direct mapping loops described in high-level labguages onto FPGAs. Different from oyher approaches, this technique does not inherit from software pipelining techniques. The control is distributed over operations, thus a finite state machine is not necessary to control the order of operations, allowing efficient harware implementations. The specification of a hardware block is done by means of LALP, a domain specific language specially designed to help the application of the techniques. While the language syntax resembles C, it contains certain constructs that allow programmer interventions to enforce or relax data dependences as needed, and so optimize the performance of the generated hardware
24
Ottoni, Guilherme de Lima. "Alocação global de registradores de endereçamento para referencias a vetores em DSPs." [s.n.], 2002. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276516.
Full textAbstract:
Orientador: Guido Costa Souza de AraujoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-10-24T12:49:20Z (GMT). No. of bitstreams: 1 Ottoni_GuilhermedeLima_M.pdf: 2467303 bytes, checksum: 3894457788c8896fac76459cfbda00e4 (MD5) Previous issue date: 2002
Resumo: O avanço tecnológico dos sistemas computacionais tem proporcionado o crescimento do mercado de sistemas dedicados, cada vez mais comuns no dia-a-dia das pessoas, como por exemplo em telefones celulares, palmtops e sistemas de controle automotivo. Devido às suas características, estas novas aplicações requerem sistemas que aliem baixo custo, alto desempenho e baixo consumo de potência. Uma das maneiras de atender a estes requisitos é utilizando processadores especializados. Contudo, a especialização na arquitetura dos processadores impõe novos desafios para o desenvolvimento de software para estes sistemas. Em especial, os compiladores - geralmente responsáveis pela otimização de código - precisam ser adaptados para produzir código eficiente para estes novos processadores. Na área de processamento de sinais digitais, como em telefonia celular, processadores especializados, denominados DSPs2, são amplamente utilizados. Estes processadores tipicamente possuem poucos registradores de propósito geral e modos de endereçamento bastante limitados. Além disso, muitas das suas aplicações envolvem o processamento de grandes seqüências de dados, as quais são geralmente armazenadas em vetores. Como resultado, o estudo de técnicas de otimização de referências a vetores tornou-se um problema central em compilação para DSPs. Este problema, denominado Global Array Reference Allocation (GARA), é o objeto central desta dissertação. O sub-problema central de GARA consiste em se determinar, para um dado conjunto de referências a vetores que serão alocadas a um mesmo registrador de endereçamento, o menor custo das instruções que são necessárias para manter este registrador com o endereço adequado em cada ponto do programa. Nesta dissertação, este sub-problema é modelado como um problema em grafos, e provado ser NP-difícil. Além disso, é proposto um algoritmo eficiente, baseado em programação dinâmica, para resolver este sub-problema de forma exata sob certas restrições. Com base neste algoritmo, duas técnicas são propostas para resolver o problema de GARA. Resultados experimentais, obtidos pela implementação destas técnicas no compilador GCC, comparam-nas com outros resultados da literatura. Os resultados demonstram a eficácia das técnicas propostas nesta dissertação
Abstract: The technological advances in computing systems have stimulated the growth of the embedded systems market, which is continuously becoming more ordinary in people's lives, for example in mobile phones, palmtops and automotive control systems. Because of their characteristics, these new applications demand the combination of low cost, high performance and low power consumption. One way to meet these constraints is through the design of specialized processors. However, processor specialization imposes new challenges to the development of software for these systems. In particular, compilers - generally responsible for code optimization - need to be adapted in order to produce efficient code for these new processors. In the digital signal processing arena, such as in cellular telephones, specialized processors, known as DSPs (Digital Signal Processors), are largely used. DSPs typically have few general purpose registers and very restricted addressing modes. In addition, many DSP applications include large data streams processing, which are usually stored in arrays. As a result, studing array reference optimization techniques became an important task in compiling for DSPs. This work studies this problem, known as Global Array Reference Allocation (GARA). The central GARA subproblem consists of determining, for a given set of array references to be allocated to the same address register, the minimum cost of the instructions required to keep this register with the correct address at alI program points. In this work, this subproblem is modeled as a graph theoretical problem and proved to be NP-hard. In addition, an efficient algorithm, based on dynamic programming, is proposed to optimally solve this subproblem under some restrictions. Based on this algorithm, two techniques to solve GARA are proposed. Experimental results, from the implementation of these techniques in the GCC compiler, compare them with previous work in the literature. The results show the effectiveness of the techniques proposed in this work
Mestrado
Mestre em Ciência da Computação
25
Kely, de Melo Oliveira Guilherme. "Compilando Haskell para .NET via F#." Universidade Federal de Pernambuco, 2010. https://repositorio.ufpe.br/handle/123456789/2389.
Full textAbstract:
Made available in DSpace on 2014-06-12T15:57:39Z (GMT). No. of bitstreams: 2
arquivo3216_1.pdf: 6659432 bytes, checksum: 29ec979f8895b39460684d09a38f9764 (MD5)
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2010Coordenação de Aperfeiçoamento de Pessoal de Nível Superior
Diferentes linguagens de programação disponibilizam diferentes formas de se implementar uma funcionalidade. Por exemplo, acessar um banco de dados usando C++ ou Python podem ser duas tarefas completamente diferentes. Por outro lado, com o surgimento da Plataforma .NET o acesso a dados com C++ .NET ou IronPython, por exemplo, se tornaram atividades muito parecidas tendo apenas algumas diferenças sintáticas. A Plataforma .NET é distribuída com um conjunto padrão de compiladores para diferentes linguagens como C#, Visual Basic .NET, JScript e J#, todas são orientadas a objetos. Com isso podemos notar uma maior atenção comercial dada ao paradigma de orientação a objetos. No entanto, esse dado não significa que devamos concluir que outros paradigmas não possam ser suportados, pelo contrário e a criação da linguagem F# é um exemplo de que a Plataforma .NET pode dar suporte a diversos paradigmas. Haskell é uma linguagem puramente funcional, não-estrita e fortemente tipada. E por ser uma linguagem de alto poder de expressão e não permitir efeitos colaterais durante sua execução, um programa escrito em Haskell se torna mais fácil de testar, otimizar e paralelizar. No entanto há um grande vazio quando tocamos na questão de ferramentas e APIs para Haskell. Devido ao fato de desenvolvedores usarem uma grande gama de ferramentas e tecnologias, cada qual com diferentes funcionalidades e tipos, tem sido historicamente difícil garantir a interoperabilidade entre as linguagens. No entanto, os compiladores e ferramentas que tem como alvo máquinas virtuais como a Plataforma .NET tiram proveito do suporte a interoperabilidade entre linguagens inerente a esses tipos de sistemas. O presente trabalho propõe um novo esquema de compilação de Haskell para a Plataforma .NET utilizando F# como linguagem intermediária. Tal abordagem nos livra dos inúmeros problemas que a geração de código diretamente para MSIL pode trazer, possibilitando irmos um pouco mais além na questão da interoperabilidade
26
Louise, de Barros Monteiro Monique. "Integrando Haskell à Plataforma .NET." Universidade Federal de Pernambuco, 2006. https://repositorio.ufpe.br/handle/123456789/2618.
Full textAbstract:
Made available in DSpace on 2014-06-12T15:59:41Z (GMT). No. of bitstreams: 2
arquivo5500_1.pdf: 3962680 bytes, checksum: 4dba3d9b94bbd26eb1eec27b1083b622 (MD5)
license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5)
Previous issue date: 2006Tradicionalmente, linguagens funcionais fornecem um grau de abstração superior ao encontrado em outros paradigmas (imperativo, orientado a objetos), o que se manifesta por meio de construções de alto nível como funções de alta ordem, aplicações parciais, polimorfismo paramétrico e, em algumas linguagens, avaliação sob demanda. Entretanto, a utilização do paradigma funcional tem-se restringido basicamente a aplicações acadêmicas. Essa restrição é em parte explicada pela ausência de ambientes de desenvolvimento e APIs que melhorem a produtividade do desenvolvedor na construção de aplicações que fazem uso das tecnologias mais recentes de desenvolvimento Web, computação distribuída, arquitetura orientada a serviços, entre outras. Por outro lado, plataformas como a Java Virtual Machine e, mais recentemente, a Plataforma .NET, disponibilizam uma amplagama de serviços e bibliotecas que satisfazem aos tipos de aplicações supracitados. O ambiente .NET, em particular, destaca-se por suportar múltiplas linguagens, apesar do suporte ser mais amplo a linguagens orientadas a objeto. Dentro desse contexto, surge a oportunidade de portar linguagens funcionais para essa plataforma, permitindo não apenas o acesso aos serviços por ela fornecidos como também uma interoperabilidade natural com outras linguagens. O objetivo deste trabalho é o desenvolvimento de uma implementação da linguagem funcional Hask ell para a Plataforma .NET. Tal implementaçãonão é trivial devido ao g a p semântico que existe entre uma linguagem funcional com avaliação sob demanda e um ambiente como o .NET. F oi desenvolvido um gerador de código capaz de gerar, a partir de um programa Hask ell, código em IL - linguagem assembly suportada pela máquina virtual. Paralelamente, foram conduzidas medições de desempenho do código gerado. Tais medições demonstraram performance razoável para váriosprogramas. Entretanto, a principal contribuição deste trabalho está na disponibilizaçãode uma implementação Hask ell que serve como principal passo rumo µa interoperabilidade com a Plataforma .NET. Além disso, a solução desenvolvida serve como um ambiente de teste e validação de diferentes alternativas de tradução de uma linguagem funcional para as construções encontradas em uma plataforma como .NET
27
MÉLO, Daniel Gondim Ernesto de. "Uma Abordagem para Construção das Etapas de Análise de um Compilador." Universidade Federal de Campina Grande, 2014. http://dspace.sti.ufcg.edu.br:8080/jspui/handle/riufcg/258.
Full textAbstract:
Submitted by Gustavo Nascimento (gustavo.diniz@ufcg.edu.br) on 2018-02-07T11:57:47Z
No. of bitstreams: 1
DANIEL GONDIM ERNESTO DE MÉLO - DISSERTAÇÃO PPGCC 2014.pdf: 1076740 bytes, checksum: 6b8c2f71701a3e6c6fa28f87faaeba62 (MD5)Made available in DSpace on 2018-02-07T11:57:47Z (GMT). No. of bitstreams: 1 DANIEL GONDIM ERNESTO DE MÉLO - DISSERTAÇÃO PPGCC 2014.pdf: 1076740 bytes, checksum: 6b8c2f71701a3e6c6fa28f87faaeba62 (MD5) Previous issue date: 2014-06-20
Capes
Compiladores são programas que traduzem um código escrito em alguma linguagem, conhecida como linguagem fonte, para um outro programa semanticamente equivalente em outra linguagem, conhecida como linguagem destino. Existem compiladores que traduzem códigos entre linguagens de alto nível. Porém, em geral, a linguagem destino mais utilizada é a linguagem de máquina ou código de máquina. Várias linguagens e ferramentas têm sido propostas dentro desse escopo a exemplo de Xtext, Stratego, CUP, ANTLR, etc. Apesar da grande quantidade, atualmente, os frameworks existentes para a construção de compiladores são de difícil compreensão e não evidenciam ao programador várias estruturas importantes, como tabela de símbolos e árvores de derivação. Adicionalmente, são muitos os detalhes específicos de cada plataforma concebida com esse propósito. Outrossim, em sua maioria, cada framework concentra-se e provê serviços para apenas uma etapa de um compilador, muitas vezes para prover serviços para mais de uma etapa se faz necessário o uso de linguagens de propósito geral, o que eleva o grau de complexidade para o projetista de Compiladores. Nesse sentido, propomos UCL (Unified Compiler Language), uma linguagem de domínio específico para o desenvolvimento das etapas de análise de Compiladores, de forma independente de plataforma e unificada. Com UCL é possível ao projetista do Compilador, especificar questões de design, tais como escolha de algoritmos a serem utilizados, tipo de scanner, entre outras características. A avaliação deste trabalho foi realizada por meio da condução de dois surveys com alunos da disciplina de Compiladores da Universidade Federal de Campina Grande, durante a execução dos projetos, que consiste no desenvolvimento de Compiladores.
Compilers are softwares that translate program codes written in some language, known as source language, to another semantically equivalent program in another programming language, known as target language. There are compilers that translate codes between high level languages. However, in general, the most widely used target language is the machine language or machine code. Several languages and tools have been proposed within this escope, e.g. Xtext, Stratego, CUP, ANTLR, etc. Despite the great quantity, currently, the existing frameworks for building compilers are difficult to understand and does not show the programmer several important structures, such as symbol table and syntax tree. Additionally, there are many specific details of each platform designed for that purpose. Moreover, in most cases, each framework focuses and provides services for only one module of a compiler. Often to provide services for more than one step it is necessary to use general purpose languages, which increases the degree of complexity. In this context, we propose UCL (Unified Compiler Language), a domain specific language for the development of the analysis modules, in a unified and platform independent way. With UCL it is possible for the compiler designer, specify design issues, such as, choice of algorithms to be used, type of scanner, among other features. The evaluation of this work was conducted through the application of two surveys with students of the compilers course from the Federal University of Campina Grande, during project execution, consisting in the development of compilers.
28
Cintra, Marcelo Silva. "Alocação global de registradores de endereçamento usando cobertura do grafo de indexação e uma variação da forma SSA." [s.n.], 2000. http://repositorio.unicamp.br/jspui/handle/REPOSIP/275891.
Full textAbstract:
Orientador: Guido Costa Souza de AraujoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-11T23:43:23Z (GMT). No. of bitstreams: 1 Cintra_MarceloSilva_M.pdf: 4931297 bytes, checksum: 7c0c9ec0d753cee26428360bb75ed2bd (MD5) Previous issue date: 2000
Resumo: O modo de endereçamento indireto é o modo mais utilizado para acessos a arrays em programas que executam em arquiteturas CISC dedicadas. A razão para isto é que o endereçamento indireto permite o cálculo rápido de endereços usando instruções curtas. Este trabalho propõe uma solução para o problema de alocação de registradores de endereçamento para referências a elementos de arrays em laços, utilizando modo de endereçamento indireto combinado com auto-incremento. O resultado é um algoritmo que minimiza o número de registradores de endereçamento e instruções de redirecionamento requeridas por um programa. Este trabalho propõe uma extensão, para o caso multi-dimensional. de trabalhos anteriores baseados na cobertura do Grafo de Indexação(IG). Este trabalho propõe ainda um algoritmo de alocação global baseado em uma variação de Static Single Assignment Forra e uma heurística para a redução do número de registradores requeridos pela cobertura do IG. Um compilador otimizante pertencente à Conexant Systems Inc. é utilizado para testar estas idéias. Resultados experimentais, usando programas reais, mostraram uma melhoria de desempenho de 11.3% no tempo de execução quando comparado com uma técnica de coloração baseada em prioridade. Devido ao impacto da alocação de registradores na geração de código, esta técnica pode melhorar substancialmente o tamanho do código gerado, reduzindo a dissipação de energia e aumentando o desempenho do sistema. Estas características são extremamente desejáveis para o projeto de computadores portáteis modernos.
Abstract: Indirect addressing is by far the most used addressing mode in programs running in embedded CISC architectures. The reason is that it enables fast address computation combined with short instructions. This work proposes a solution to the problem of allocating address registers to array references within loops, when using indirect addressing combined with auto-increment. The result is an algorithm that minimizes the number of address registers and redirect instructions required by a program. It extends previous work using Indexing Graph(lG) covering to the multidimensional case, and proposes a global allocation algorithm based on a variation of Static Single Assignment Form. This work also presents a heuristic that aims at reducing the number of address registers required by the covering of the IG. An optimizing production compiler from Conexant Systems Inc. is used to test the approach. Experimental results, using real world-programs, showed an 11% performance improvement when compared to a priority-based register coloring technique. Because of the impact of register alocation in code generation, this technique can substantially improve code size, power dissipation and performance, without increasing cost. These are very desirable features for the design of modern portable computers.
Mestrado
Mestre em Ciência da Computação
29
Neves, Carlos Rafael Gimenes das. "JavAsync : extensão da linguagem Java para tratamento de eventos assíncronos." Instituto Tecnológico de Aeronáutica, 2013. http://www.bd.bibl.ita.br/tde_busca/arquivo.php?codArquivo=2858.
Full textAbstract:
Quando contando apenas com o que é oferecido por linguagens orientadas a objetos, como o Java, os desenvolvedores tendem a utilizar apenas chamadas síncronas a métodos, utilizando-se de artifícios para obter comportamento assíncrono, o que comumente quebra o modelo original do sistema, acrescentando uma série de efeitos colaterais indesejados, tais como acoplamento desnecessário entre classes e construções passíveis de erros. O acoplamento desnecessário normalmente aparece quando uma classe precisa ser notificada sobre a ocorrência de eventos em outra classe na mesma pilha de chamadas em tempo de execução. Propomos uma extensão à linguagem Java para permitir a execução assíncrona de métodos, a notificação e o tratamento assíncronos de eventos ocorridos durante a execução normal do programa em classes presentes na pilha de chamadas corrente, como uma alternativa nativa, simples e que não force acoplamento adicional entre as classes envolvidas. Denominamos JavAsync à linguagem Java assim estendida. Com essa extensão, esperamos que os desenvolvedores possam utilizar comunicação assíncrona desde o início do ciclo de desenvolvimento, sem que precisem realizar modificações à estrutura original do software em desenvolvimento e sem que precisem se preocupar com threads e com o registro dos tratadores de eventos.
30
Ottoni, Desirée Leopoldo da Silva. "Algoritmos para alocação de pilha de execução baseados em união de variaveis para DSPs." [s.n.], 2004. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276517.
Full textAbstract:
Orientador: Guido Costa Souza de AraujoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-10-24T12:45:09Z (GMT). No. of bitstreams: 1 Ottoni_DesireeLeopoldodaSilva_M.pdf: 1826554 bytes, checksum: 11256685b6244447ac6c729e9b8394ba (MD5) Previous issue date: 2004
Resumo: Nos últimos anos, uma classe importante de aplicações em telecomunicações e multimídia tem despertado um grande interesse no projeto e pesquisa de processadores dedicados, em particular de DSPs2. Além de desempenho, estas aplicações demandam baixo consumo de potência e custo reduzido. Com o propósito de atender a esta demanda, projetistas de DSPs precisam especializar suas arquiteturas com unidades funcionais dedicadas. Devido a rigorosas restrições de projeto, é comum encontrar DSPs com poucos registradores de propósito geral e modos de endereçamento restritos, baseados em unidades especializadas no cálculo de endereços de memória. Por serem arquiteturas irregulares, as otimizações de código existentes nos compiladores para processadores de propósito geral não são eficientes para DSPs. Isto resultou em um aumento no interesse por pesquisa de técnicas de otimizações para estes processadores. Esta dissertação propõe duas novas técnicas de otimização de código para o problema de Offset Assignment(OA). Uma solução para OA visa encontrar uma disposição das variáveis automáticas de um programa na memória, de forma a minimizar o uso de instruções explícitas de endereçamento, obtendo assim um código de melhor desempenho. Este tipo de otimização é um dos problemas centrais de compilação para DSPs, dado que grande parte das instruções geradas para estes processadores é de endereçamento. Uma extensa revisão bibliográfica sobre Offset Assignment é apresentada nesta dissertação. Além disso, são propostos dois novos algoritmos que resolvem variações deste problema: a heurística CSOA, que resolve o problema de Simple Offset Assignment, e a heurística CGOA, que resolve o problema de General Offset Assignment. As duas heurísticas utilizam informações de longevidade das variáveis de modo a realizar união seletiva de variáveis na memória, resultando em uma melhor utilização de modos de endereçamento de auto-incrementojdecremento. Além das duas técnicas propostas, foram implementadas outras quatro técnicas existentes na literatura. Uma análise comparativa, baseada num conjunto de experimentos usando o benchmark Mediabench, revelou a superioridade de CSOA e CGOA sobre os outros métodos
Abstract: In recent years, an important class of applications in telecommunication and multimedia has created a large interest in the design and research of dedicated processors, specially Digital Signal Processors (DSPs). In addition to performance, these applications demand low power consumption and reduced cost. In order to achieve these goals, DSP designers need to specialize the architecture with dedicated functional units. Due to their stringent design constraints, it is common to find DSPs containing very few general-purpose registers, and restricted addressing modes, typically based on specialized address generation units. Given their irregular architectures, compiler code optimization techniques for general-purpose processors are not efficient for DSPs. This has resulted in an increasing interest in the research of optimization techniques target to such processors. This dissertation proposes two novel code optimization techniques for the Offset Assignment (OA) problem. A solution to OA aims at finding a memory layout for automatic variables in a program, such that the use of explicit memory addressing instructions is minimized, thus increasing the performance of the resulting code. This type of optimization is one of the central problems in compilation for DSPs, as address computation accounts for a large share of the instructions generated for these processors. A long survey on OA is presented in this dissertation. Moreover, two new algorithms to solve variations of OA are proposed: the CSOA heuristic, to solve the Simple Offset Assignment problem; and the CGOA heuristic, which solves the General Offset Assignment. Both techniques use liveness information to perform selective coalescing of variables in memory, resulting in an improved use of auto-increment/decrement addressing modes. In addition to the two proposed algorithms, four other techniques from the literature have been implemented. A comparative analysis, based on a set of experiments using the Media Bench benchmark, has revealed the superiority of CSOA and CGOA with respect to the other methods
Mestrado
Mestre em Ciência da Computação
31
Librelotto, Giovani Rubert. "Um Compilador para a linguagem RS distribuída." reponame:Biblioteca Digital de Teses e Dissertações da UFRGS, 2001. http://hdl.handle.net/10183/25064.
Full textAbstract:
A Linguagem RS é destinada a programação de núcleos reativos centralizados. Tais núcleos são responsáveis por toda a lógica de um sistema reativo, manipulando os sinais de entrada, realizando as reações e gerando os sinais de saída. Sendo sua idéia inicial tratar apenas processos centralizados, não houve a preocupação com a distribuição. Este trabalho tem como principal objetivo apresentar os aspectos introduzidos de uma nova versão para a Linguagem e para o Compilador RS, que possibilitam a execução de programas distribuídos. Além da possibilidade de execução de sistemas reativos distribuídos, foi acrescentado à Linguagem RS extensões já previstas na sua criação, como sinais inibidores, regras de exclusão mútua e concomitância, a possibilidade de disparo de mais de uma regra em um mesmo instante e a limpeza léxica do código fonte RS. As modificações incorporadas nesta nova versão da linguagem, foram efetivadas através de um novo compilador, chamado de Compilador RS 5.0. O protótipo implementado oferece a geração de três formatos de código: o formato padrão da linguagem RS (os autômatos e as regras correspondentes), códigos na linguagem C para a simulação dos autômatos (tanto para programas distribuídos quanto não-distribuídos) e arquivos no formato portável OC, que é um formato de código objeto padrão para as linguagens reativas. Para a distribuição e implementação da Linguagem RS foi necessária a criação de um novo núcleo de comunicação do MDX, que é responsável pela comunicação dos autômatos RSD. Este núcleo é dividido em três partes. A primeira trata da definição de um modelo formal com as mudanças necessárias para que a linguagem RS consiga trabalhar de forma distribuída, a segunda mostra o projeto do novo núcleo MDX e a terceira apresenta a implementação em C e MDX dos autômatos gerados pelo Compilador RS 5.0. Por fim, exemplos de aplicação desta nova linguagem são apresentados, onde podem ser vistos a importância e o acréscimo proporcionado por este trabalho tanto à linguagem RS quanto à programação de sistemas reativos síncronos.The RS language is intended to the programming of centralized reactive kernels. Such kernels are responsible for the logic of a reactive system, manipulating the input signals, carrying through the reactions and generating the output signals. Being its initial idea to treat only centered processes, it did not have the concern with the distribution. The main objective of this work is to describe the process of creation of a new version for the Language and Compiler RS, that make possible the execution of distributed programs. Beyond the possibility of execution distributed reactive systems, it was added to RS language foreseen extensions already in its creation, as inhibiting signals, rules of manual exclusion and concurrence, the possibility of detonation of more than a rule in one exactly instant and the lexical cleanness of the RS code source. The modifications incorporated in this new version of the language, had been accomplished through a new compiler, called Compiler RS 5.0. The implemented archetype offers the generation of three formats of code: the standard format of RS language (the corresponding automatons and rules), codes in the language C for the simulation of the automatons and archives in OC portable format, that is a object format code standard for the reactive languages. For the distribution and implementation of Language RS was necessary the creation of a new kernel of communication of the MDX, that is responsible for the communication of RSD automatons. It is divided in three parts. The first one deals with the definition of a formal model that defines the necessary changes so that RS language obtains to work of distributed form, the second shows the design of new MDX kernel and third presents the implementation in C and MDX of the automatons generated for Compiler RS 5.0. Finally, examples of application of this new language are presented, where the importance and the proportionate upgrade for this work to RS language how to the programming of synchronous reactive systems can in such a way be seen.
32
Ferreira, Rodrigo Augusto Barbato. "Uma implementação distribuida da Maquina Virtual JAVA visando o compartilhametno do compilador "just-In-Time"." [s.n.], 2001. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276432.
Full textAbstract:
Orientador: Guido Costa Souza de AraujoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-07-27T17:17:44Z (GMT). No. of bitstreams: 1 Ferreira_RodrigoAugustoBarbato_M.pdf: 7083497 bytes, checksum: e0954b25f044d75d0166d511f5bbe192 (MD5) Previous issue date: 2001
Resumo: A compilação Just-In- Time (JIT) é uma técnica amplamente utilizada no aperfeiçoamento do desempenho da Máquina Virtual Java (JVM, do inglês Java Virtual Machine). Contudo, o tempo gasto internamente pelo compilador JIT degrada, em muitos casos, o tempo de execução das aplicações. Algumas técnicas têm sido usadas com o objetivo de diminuir o impacto negativo do JIT sobre a execução, ainda sim preservando a sua eficácia. Entretanto, sempre haverá uma relação inversa entre o tempo gasto pelo compilador JIT e o tempo de execução do código objeto por ele produzido. Segundo nossa concepção, uma Máquina Virtual Java que visa usuários finais executa o mesmo código a maior parte do seu tempo. Os usuários sempre utilizam os mesmos aplicativos, os quais são tipicamente compostos pelo mesmo conjunto de classes. Por outro lado, em grandes companhias, dezenas ou até mesmo centenas de empregados compartilham a mesma aplicação ou pacote de aplicações. Usualmente, eles estão conectados a uma mesma Intranet, rápida e segura. Neste cenário, o esforço do JIT por usuário é repetitivo e bem maior que o estritamente necessário. O objetivo deste trabalho é o de desacoplar atividades de tempo de ligação da JVM para um servidor compartilhado, de maneira distribuída. Desta forma, cada cliente JVM se torna um componente de software muito simples que executa código Java nativamente, dispensando um JIT ou interpretador. Todas as atividades complexas de tempo de ligação - como detecção de erros, verificação do formato binário Java e compilação JIT - são efetuadas pelo servidor, que armazena suas respostas em uma cache. Este documento é uma descrição de uma implementação alternativa da Máquina Virtual Java que inova em muitos pontos. Em particular, são contribuições deste trabalho: as técnicas para a detecção e recuperação de contextos repetidos em tempo de ligação; um procedimento alternativo, off-line, para a verificação do bytecode Java; o projeto e a implementação de uma representação intermediária específica para Java; a descrição, em detalhes, de diversos aspectos de implementação da JVM
Abstract: Just-In-Time (JIT) compilation is a well-known technique used to improve the execution time in the Java Virtual Machine (JVM). However, the amount of time used by the JIT internals degrades, in many cases, the application execution time. Some techniques have been used to decrease the JIT overhead, while still keeping its effectiveness. However, the trade-off between the JIT running time and its object code execution time will always existo From our observation, an end-user Java Virtual Machine deals with the same code most of its time. Users always launch the same applications, which are typically composed of the same set of classes. On the other hand, in big companies, dozens or even hundreds of employees share the same application or application suite. Usually, they are connected under the same fast and secure Intranet. In this scenario, the per-user JIT effort is repetitive and largely greater than the strictly required. The goal of our work is to detach linking activities from the JVM to a shared server, on a distributed fashion. By doing that, the client JVM turns to be a very simple piece of software that runs Java code natively, not requiring a JIT or interpreter. All complex linking activities - like link-time error checking, class file verification and JIT compilation are done by the server, which caches its responses. This document is a description of an alternate implementation of the Java Virtual Machine that innovates. It covers specially: the techniques for detecting and caching repetitive link-time contexts; an alternate, offline, byte code verification procedure; the design and implementation of a Java specific intermediate representation; the detailed description of many JVM implementation issues
Mestrado
Mestre em Ciência da Computação
33
Silva, Marcos Antonio Vieira da. "Modi - um ambiente de desenvolvimento para aplicações voltadas a sistemas dedicados." [s.n.], 2002. http://repositorio.unicamp.br/jspui/handle/REPOSIP/260255.
Full textAbstract:
Orientador: Elnatan Chagas FerreiraTese (doutorado) - Universidade Estadual de Campinas, Faculdade de Engenharia Eletrica e de Computação
Made available in DSpace on 2018-08-02T22:57:35Z (GMT). No. of bitstreams: 1 Silva_MarcosAntonioVieirada_D.pdf: 2154516 bytes, checksum: c5cfa588aca6bc46461c53df90f4d2c5 (MD5) Previous issue date: 2002
Doutorado
34
Costa, Bruno Kraychete da. "Compressão de byte-code utilizando recuperação de sintaxe abstrata." [s.n.], 2000. http://repositorio.unicamp.br/jspui/handle/REPOSIP/275890.
Full textAbstract:
Orientador: Guido Costa Souza de AraujoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-11T23:31:29Z (GMT). No. of bitstreams: 1 Costa_BrunoKraycheteda_M.pdf: 9665605 bytes, checksum: 16223ea98c66ee77839bcdaae9286d78 (MD5) Previous issue date: 2000
Resumo: Com os avanços da tecnologia nas áreas de comunicação sem fio e computação pessoal, os chamados computadores portáteis. ou handhelds estão se tornando alvo de muita atenção em Computação. Por outro lado, linguagens cujo alvo são máquinas virtuais (ex. Java), têm permitido a construção de sistemas portáteis distribuídos que são independentes do processador. Os handhelds são normalmente projetados em torno de um processador dedicado e uma pequena quantidade de memória, de modo a manter baixo o custo do projeto. As limitações de memória encontradas em tais dispositivos, e o aumento da demanda por banda disponível. nas redes têm renovado o interesse em pesquisas voltadas para a compressão de código móvel. Neste trabalho, nós mostramos um método de compressão para estes dispositivos baseado na recuperação das Árvores de Sintaxe Abstrata (ASA) do programa. Resultados experimentais, utilizando o Benchmark JVM98, revelaram uma melhoria nas razões de compressão em relação àquelas obtidas usando exclusivamente o algoritmo Lempel-Ziv- Welch.
Abstract: With the advances in technologies for wireless communications and personal computing, the so called portable appliances or handhelds are expected to become mainstream computer devices. Gn the software side, languages targeted to virtual machines (eg. lava) have enabled the design of flexible mobile distributed systems that are independent of the underlying processor. In order to keep costs low, handhelds are usually designed around a cheap dedicated processor and a small memory set. The memory size constraints found on such devices, and the increasing demand for bandwidth have been renewing the research interest towards new program compression techniques. In this work, we show a compression method for these devices, that is based on the recovery of the program Abstract Syntax Trees. Experimental results, using the JVM98 Benchmark, reveal an improvement on the compression ratio over the LZW algorithm when the ASTs are recovered before com pression.
Mestrado
Mestre em Ciência da Computação
35
Oliveira, Victor Matheus de Araujo 1988. "Uma coleção de estudos de caso sobre o uso da linguagem Halide de domínio-específico em processamento de imagens e arquiteturas paralelas." [s.n.], 2013. http://repositorio.unicamp.br/jspui/handle/REPOSIP/259825.
Full textAbstract:
Orientador: Roberto de Alencar LotufoDissertação (mestrado) - Universidade Estadual de Campinas, Faculdade de Engenharia Elétrica e de Computação
Made available in DSpace on 2018-08-24T09:58:17Z (GMT). No. of bitstreams: 1 Oliveira_VictorMatheusdeAraujo_M.pdf: 5485933 bytes, checksum: 54457856261050bf86360bc7acbb2e5b (MD5) Previous issue date: 2013
Resumo: Um novo desenvolvimento no campo de Linguagens de Domínio-Específico são linguagens de programação que podem funcionar tanto em CPUs multi-núcleo quanto em GPUs. Nesta dissertação, avaliamos Halide, uma Linguagem de Domínio Específico (DSL) para processamento de imagens. Halide funciona tanto em CPUs como em GPUs e almeja ser uma forma mais simples e eficiente, em termos de desempenho, de expressar algoritmos da área do que as alternativas tradicionais. Para mostrar o potencial e as limitações da linguagem Halide, fazemos nesta dissertação alguns estudos de caso com algoritmos que acreditamos ser bons exemplos de categorias-chave em Processamento de Imagens, especialmente em manipulação e edição de Imagens. Comparamos o desempenho e simplicidade de implementação desses problemas com implementações em C++ usando \emph{threads} e vetorização, para arquiteturas CPU multi-núcleo, e OpenCL, para CPUs e GPUs. Mostramos que há problemas na implementação atual de Halide e que alguns tipos de algoritmos da área não podem ser bem expressos na linguagem, o que limita a sua aplicabilidade prática. Entretanto, onde isso é possível, Halide tem performance similar à implementações em OpenCL, onde vemos que há de fato ganho em termos de produtividade do programador. Halide é, portanto, apropriado para um grande conjunto de algoritmos usados em imagens e é um passo na direção certa para um modo de desenvolvimento mais fácil para aplicações de alto desempenho na área
Abstract: A development in the field of Domain-Specific Languages (DSL) are programming languages that can target both Multi-Core CPUs and accelerators like GPUs. We use Halide, a Domain-Specific Language that is suited for Image Processing tasks and that claims to be a more simple and efficient (performance-wise) way of expressing imaging algorithms than traditional alternatives. In order to show both potential and limitations of the Halide language, we do several case studies with algorithms we believe are representatives of key categories in today's Image Processing, specially in the area of Image Manipulation and Editing. We compare performance and simplicity of Halide implementations with multi-threaded C++ (for multi-core architectures) and OpenCL (for CPU and GPUs). We show that there are problems in the current implementation of the DSL and that many imaging algorithms cannot be efficiently expressed in the language, which limits its practical application; Nevertheless, in the cases where it is possible, Halide has similar performance to OpenCL and is much more simple to develop for. So we find that Halide is appropriate for a big class of image manipulation algorithms and is a step in the right direction for an easier way to use GPUs in imaging applications
Mestrado
Engenharia de Computação
Mestre em Engenharia Elétrica
36
Nakashima, Raul Junji. "Paralelização de programas sisal para sistemas MPI." Universidade de São Paulo, 1996. http://www.teses.usp.br/teses/disponiveis/76/76132/tde-06052008-105502/.
Full textAbstract:
Este trabalho teve como finalidade a implementação de um método para a paralelização parcial de programas, escritos na linguagem funcional, SISAL utilizando as bibliotecas do padrão MPI (Message Passing Interface). Para tal, propusemos a transformação dos programas SISAL através do particionamento do loop paralelo forall, através do método de particionamento slice e a utilização do modelo de implementação do paralelismo SPMD (Single Program Multiple Data) no estilo de programas mestre/escravo. A validação de nossa proposta foi obtida através da realização de testes onde foram comparados os resultados obtidos com os programas originais e os programas com as alterações propostasThis work describes a method for the partial parallelization of SISAL programs into programs with calls to MPI routines. We focused on the parallelization of the forall loop (through slicing of the index range). The generated code is a master/slave SPMD program. The work was validated through the compilation of some simple SISAL programs and comparison of the results with an unmodified version
37
Figueiredo, Adriana Maria Cunha de Melo. "Um compilador para um sistema de gerenciamento de metadados baseado em MOF." [s.n.], 2004. http://repositorio.unicamp.br/jspui/handle/REPOSIP/259495.
Full textAbstract:
Orientador : Manuel de Jesus MendesDissertação (mestrado) - Universidade Estadual de Campinas, Faculdade de Engenharia Eletrica e de Computação
Made available in DSpace on 2018-08-03T23:26:28Z (GMT). No. of bitstreams: 1 Figueiredo_AdrianaMariaCunhadeMelo_M.pdf: 2152436 bytes, checksum: 1e8d87ef53f87c9ba601c7e63e879f49 (MD5) Previous issue date: 2004
Mestrado
Engenharia de Computação
Mestre em Engenharia Elétrica
38
Felicio, Cristiano Lino. "Representações internas e geração de codigos no compilador redirecionavel Xingo." [s.n.], 2005. http://repositorio.unicamp.br/jspui/handle/REPOSIP/276387.
Full textAbstract:
Orientadores: Paulo Cesar Centoducatte, Guido Costa Souza de AraujoDissertação (mestrado) - Universidade Estadual de Campinas, Instituto de Computação
Made available in DSpace on 2018-08-04T08:52:36Z (GMT). No. of bitstreams: 1 Felicio_CristianoLino_M.pdf: 971885 bytes, checksum: 8ba5bf45f0d0284fcc7671ce0be406f7 (MD5) Previous issue date: 2005
Resumo: Devido ao aumento da complexidade dos novos processadores, especialmente processadores DSPs, a capacidade dos compiladores de gerar um código altamente otimizado para as novas arquiteturas de computadores é cada vez mais desafiador. O compilador Xingó tem como objetivos possibilitar pesquisas em otimização e geração de código para novas arquiteturas. Para permitir tais pesquisas, é necessário que o compilador possua uma infra-estrutura capaz de representar, de uma maneira simples e correta, o código nas diversas fases de compilação. Este trabalho apresenta as principais representações de programa do compilador Xingó, bem como os módulos que fazem a tradução de um programa, em uma representação origem, para um programa em uma representação destino (intermediária ou final). Estes móulos compõem o front-end do compilador, que leva à Representação Intermediária Xingó, e parte do back-end, com destaque para a Infra-Estrutura de Geração de Código do Xingó. A Representação Intermediária do Xingó é de fácil manipulação, independente de máquina e apresenta uma sintaxe muito próxima à da linguagem C, por isso tem permitido otimizações independente de máaquina e pode ser traduzida em código C compilável. Já a Infra-Estrutura de Geração de Código apresenta facilidades no desenvolvimento de novos geradores de código, principalmente porque os detalhes da máquina alvo são externos ao compilador, sendo incluídos através de parâmetros configuráeis e módulos bem definidos. Os testes realizados até o presente momento validam parte da Infra-Estrutura de Geração de Código e têm demonstrado uma boa qualidade do Código Intermediário Xingó. Os testes mostram que o Código Intermediário estão sendo corretamente representado para todos os programas do benchmark NullStone (6611 programas) e para uma quantidade razoável de programas dos benchmarks MediaBench e SPEC. Os resultados alcançados até o momento trazem novas oportunidades em pesquisas na área de compiladores, especialmente otimização e geração de código
Abstract: Due to the increasing complexity of the new processors, mainly DSPs processors, the capacity of generating highly optimized code for the new computer architectures by the compilers is increasingly motivating. The Xingó compiler has as goal allow research in code optimization and code generation for new architectures. In order to enable such researches, is necessary to the compiler to provide an infrastructure capable of representing, in an easy and correct form, the code in the several compiling phases. This work presents the main program representations of the Xingó compiler, and the modules that perform the conversion of a program, in a base representation, to a program in a destination representation (intermediate or ultimate). These modules constitute the front-end of the compiler, that generates the Xingó Intermediate Representation, and share of the back-end, with highlight to the Xingó Code Generation Infrastructure. The Xingó Intermediate Representation is easy to use, it is machine independent and has a very approximate syntax of the C language, thereby it has enabled to perform machine independent optimizations and is able to be converted to C Code. Upon the Code Generation Infrastructure, it provides facilities to development of new code generators, mainly because the details of the target machine are outside to the compiler, been included across configurable parameters and well-defined modules.The tests completed up to now validate piece of the Code Generation Infrastructure and reveal good quality of the Xingó Intermediate Code. The testes show that the Intermediate Code is been correctly generated to any programs of the NullStone benchmark (6611 programs) and also to a reasonable quantity of programs of the MediaBench and SPEC benchmarks. The test results acquired up to now conduce to new opportunities for researches on areas such as optimization and code generation
Mestrado
Ciência da Computação
Mestre em Ciência da Computação
39
Restovic, Valderrama Maria Inés. "Compilador ASN.1 e codificador/decodificador para BER." [s.n.], 1992. http://repositorio.unicamp.br/jspui/handle/REPOSIP/259533.
Full textAbstract:
Orientador: Manuel de Jesus MendesDissertação (mestrado) - Universidade Estadual de Campinas, Faculdade de Engenharia Elétrica e de Computação
Made available in DSpace on 2018-08-18T21:31:47Z (GMT). No. of bitstreams: 1 RestovicValderrama_MariaInes_M.pdf: 1435363 bytes, checksum: 073357e2857410d0a58e683b2837ca3e (MD5) Previous issue date: 1992
Resumo: Neste trabalho apresenta-se uma ferramenta chamada Compilador ASN.1, cujo objetivo é fornecer uma representação concreta para a sintaxe abstrata ASN.1, de forma que, as especificações das PDU's dos protocolos de aplicação, geralmente escritas em ASN.1, possam ser utilizadas computacionalmente. Uma das funções prioritárias da camada de apresentação de um protocolo de comunicação é produzir uma codificação dos valores destas PDU's, baseando-se nas regras definidas pela norma BER. Assim, o compilador deve fornecer numa segunda tarefa, as rotinas de codificação e decodificação específicas para cada PDU compilada, utilizando um conjunto de funções que se encontram em duas bibliotecas auxiliares que realizam estas conversões
Abstract: This work presents a tool called "Compilador ASN.1", which main objective is to provide a concrete representation for the abstract syntax ASN.1, in order to translate the application protocol PDU's specification, written in ASN.1, to the C language. One of the main functions of the presentation layer is produce an encode-decode for the PDU's data values, based on the BER norm. Therefore, a second compiler task is to provide the specific encode-decode routines for each compiled PDU, using a function set available in two complementary libraries that carry out these conversions
Mestrado
Automação
Mestre em Engenharia Elétrica
40
Honorio, Bruno Chinelato. "Melhorando o desempenho de aplicações transacionais através de anotações do programador." Universidade Estadual Paulista (UNESP), 2018. http://hdl.handle.net/11449/157064.
Full textAbstract:
Submitted by Bruno Chinelato Honorio (brunochonorio@gmail.com) on 2018-09-16T23:56:19Z
No. of bitstreams: 1
DissertacaoMestrado.pdf: 942500 bytes, checksum: 267b4e03ea0654a9a66bd58f2490310b (MD5)Rejected by Elza Mitiko Sato null (elzasato@ibilce.unesp.br), reason: Solicitamos que realize correções na submissão seguindo as orientações abaixo: Problema 01) Está faltando o LOGO (Símbolo)da Universidade/Câmpus na capa do seu trabalho.(este item é obrigatório) Problema 02) Solicito que corrija a descrição na natureza da pesquisa na folha de rosto e insira na folha de aprovação): Dissertação apresentada como parte dos requisitos para obtenção do título de Mestre em Ciência da Computação, junto ao Programa de Pós-Graduação em Ciência da Computação, do Instituto de Geociências e Ciências Exatas da Universidade Estadual Paulista “Júlio de Mesquita Filho”, Câmpus de Rio Claro Problema 03) A paginação deve ser sequencial, iniciando a contagem na folha de rosto e mostrando o número a partir da introdução, a ficha catalográfica ficará após a folha de rosto e não deverá ser contada; a contagem no seu arquivo começou na introdução. Problema 04) Quando a financiadora é FAPESP, deve constar o nome dela e o número do processo também na folha de aprovação e nos agradecimentos, é norma do convênio. Lembramos que o arquivo depositado no repositório deve ser igual ao impresso, o rigor com o padrão da Universidade se deve ao fato de que o seu trabalho passará a ser visível mundialmente. Agradecemos a compreensão on 2018-09-17T14:32:13Z (GMT)
Submitted by Bruno Chinelato Honorio (brunochonorio@gmail.com) on 2018-09-19T22:38:43Z No. of bitstreams: 1 dissertacaoMestrado.pdf: 1125894 bytes, checksum: f24c8da48aae1c09a95bd67d010c2e68 (MD5)
Approved for entry into archive by Elza Mitiko Sato null (elzasato@ibilce.unesp.br) on 2018-09-20T14:44:36Z (GMT) No. of bitstreams: 1 honorio_bc_me_sjrp.pdf: 1093610 bytes, checksum: 238491c1445e63f7afbd08da117f2a87 (MD5)
Made available in DSpace on 2018-09-20T14:44:36Z (GMT). No. of bitstreams: 1 honorio_bc_me_sjrp.pdf: 1093610 bytes, checksum: 238491c1445e63f7afbd08da117f2a87 (MD5) Previous issue date: 2018-08-09
Fundação de Amparo à Pesquisa do Estado de São Paulo (FAPESP)
Memória Transacional (Transactional Memory – TM) possibilita que programadores utilizem-se do conceito de transação na escrita de código concorrente. Nesse contexto, uma transação pode ser entendida como um bloco de instruções que é executado atomicamente e de forma isolada, ou seja, os estados intermediários no processamento de uma transação não são vistos pelas demais. Embora inicialmente confinada ao ambiente acadêmico, TM está se tornando cada vez mais popular. Prova disto é a adição de hardware transacional aos novos processadores da Intel e IBM, além de suporte para codificação de transações provido por compiladores como o GCC. A grande vantagem do modelo transacional é o maior nível de abstração fornecido ao programador, facilitando a escrita de programas concorrentes e evitando erros de sincronização famosos causados pelas travas (locks), como o deadlock. Infelizmente, o suporte em software para execução de transações ainda não provê desempenho muito bom. Em particular, o código transacional, produzido por compiladores e o sistema de tempo de execução associado, ainda pode ser considerado ineficiente. Nesta dissertação é realizado um estudo atualizado sobre a geração de código transacional do compilador GCC com o objetivo de encontrar a razão da deficiência de desempenho do compilador. O trabalho feito indica que uma das principais fontes de ineficiência são as barreiras de leitura e escrita inseridas pelo compilador. O problema dessa instrumentação acontece quando o compilador não consegue determinar, em tempo de compilação, se uma região de memória será acessada concorrentemente ou não, forçando o compilador a tomar uma decisão pessimista e instrumentar essa região de memória. Esse fenômeno é chamado de instrumentação excessiva. Para superar essas limitações, esta dissertação propõe uma nova construção de linguagem através de uma nova cláusula pragma que permite que programadores especifiquem quais regiões de memória não precisam ser instrumentadas. Para validar a nova cláusula pragma, esta dissertação conduziu experimentos usando o pacote STAMP, composto por aplicações transacionais. Os resultados obtidos mostram um grande ganho de desempenho para as aplicações que usaram o pragma proposto, com essas aplicações sendo até 7.2x mais rápidas que o código original gerado pelo GCC.
Transactional Memory (TM) allows programmers to utilize the concept of transaction for writing concurrent code. In this context, a transactioncan be extended as a block of instructions that is executed atomically and isolated, that is, the intermediate states of the processing of a transaction can not be seen by the other transactions. Although initially confined to the academic field, TM is becoming more popular. An evidence of this is the addition of transactional hardware to the new processors from Intel and IBM, as well as the support for transactional code provided by compilers such as GCC. The biggest advantage to the transactional model is the bigger level of abstraction provided to the programmer, making the process of writing parallel code easier, as well as avoiding famous synchronization errors caused by traditional locks, such as the deadlock problem. Unfortunately, the software support for execution of transaction still does not provide a good performance. In particular, transactional code, produced by compilers and the associated runtime system, can still be considered inefficient. This thesis performs an up-to-date study of the GCC transactional code generation and with the objective to find where the main performance losses are coming from. The study done indicates that one of the main sources of inefficiency is the read and write barriers inserted by the compiler. The problem of this instrumentation is that the compiler cannot determine, at compile time, if a memory region will be accessed concurrently or not, forcing the compiler to take a pessimist approach and instrument this memory region. This phenomenom is called Over-instrumentation. To overcome these limitations, this thesis proposes a new language construct through a new pragma clause that allows programmers to specify which memory regions do not need to be instrumented. To validade the new pragma clause, this thesis conducted experiments using the STAMP benchmark suite, composed of transactional applications. The obtained results show a great performance gain for applications that used the proposed pragma, with them being up to 7.2x faster than the original code generated by GCC.
2016/12103-7
41
Nakashima, Raul Junji. "Análises estatísticas para a paralelização de linguagens de atribuição única para sistemas de memória distribuída." Universidade de São Paulo, 2001. http://www.teses.usp.br/teses/disponiveis/76/76132/tde-24062008-172320/.
Full textAbstract:
Este trabalho descreve técnicas de análise estática de compilação baseadas na álgebra e programação linear que buscam otimizar a distribuição de loops forall e array em programas escritos na linguagem S/SAL visando à execução em máquinas paralelas de memória distribuídas. Na fase de alinhamento, nós trabalhamos com o alinhamento de hiperplanos onde objetivo é tentar encontrar as porções dos diferentes arrays que necessitam ser distribuídas juntas. Na fase de divisão, que tenta quebrar em partes independente dados e computações, nós usamos duas funções afins, a função de decomposição de dados e a função de decomposição de computação. A última fase, o mapeamento, distribui os elementos de computação nos elementos de processamento usando um conjunto de inequações. As técnicas foram implementadas num compilador SISAL, mas pode ser usada sem mudanças em outras linguagens de associação simples e com a adição de análise de dependências pode ser usada em linguagens imperativas.This work describes static compiler analysis techniques based on linear algebra and linear programming for optimizing the distribution of forall loops and of array elements in programs written in the SISAL programming language for distributed memory parallel machines. In the alignment phase, attempt is made in the identification of portions of different arrays that need to be distributed jointly by means of alignment of hyperplanes. In the partitioning phase, effort is made in breaking as even possible the computation and pertinent data in independent parts, by means of using related functions: the data decomposition function and the computation decomposition function. The last phase is dedicated to the mapping, which comprises the distribution of the elements of computation into the existing processing elements by means of a set of inequations. These techniques are being implemented in a SISAL compiler, but can be also used without changes by means of other single assignment languages or, with the addition of dependency analysis when using other set of languages, as well.
42
Traina, Antônio Fernando. "Proposta de uma linguagem Java para um ambiente paralelo-JAPAR." Universidade de São Paulo, 2000. http://www.teses.usp.br/teses/disponiveis/76/76132/tde-28042014-145402/.
Full textAbstract:
Com o crescente número de usuários de computadores, novas ferramentas têm sido apresentadas com a finalidade de aumentar a eficiência dos computadores, meio para que seus usuários disponham de recursos automatizados. Mais recentemente, máquinas ligadas em rede de computadores e o fenômeno Internet tornaram necessárias ferramentas específicas para este tipo particular de uso. Entre as principais respostas a essas necessidades surgiu a linguagem Java, que tem ganhado adeptos tanto na comunidade científica como no mercado. Surge daí a necessidade de buscar formas alternativas para o uso de computadores em rede. Entre as soluções propostas encontra-se a de arquiteturas e linguagens paralelas. Estas ferramentas, ainda em fase experimental, apresentam soluções que podem a médio e longo prazo serem viáveis, desde que estudos e pesquisas mostrem sua viabilidade. Neste trabalho investiga-se a aplicação do conceito de paralelismo em linguagens para rede, mais especificamente a linguagem Java. A proposta é estudar as possíveis formas para se explorar o paradigma de linguagens paralelas em ambientes Java. Para isto, apresenta-se uma pesquisa relativa as principais linguagens paralelas disponíveis na literatura, de forma a conhecer as melhores soluções apresentadas por essas linguagens. O trabalho apresenta também um estudo realizado em um conjunto de ferramentas Java disponíveis no mercado. Finalmente, propõe-se um novo ambiente que possa disponibilizar ao usuário os melhores recursos da linguagem Java, explorando as melhores soluções encontradas na literatura.With the increasing number of computer users, new tools have been presented to improve the computers efficiency and to make automated resources available for those users. Nowadays, the use of computers in a network and the Internet phenomenon requires specific tools. Among them, the Java language appears as an important tool, which has been attracting users in both the scientific and commercial communities. At the same time the computer networks are becoming more popular and some problems have emergent concerned to the networks assessment and connections. It is necessary to look for alternative ways of handling the network computer systems. The parallel architectures and languages appear among the proposed solutions. These tools are still in an experimental phase, studies and researches being necessary additional to confirm their feasibility. In this work we investigate the application of parallelism concepts in languages for networks, and particular we deal with the Java language. The aim is to study the possible approaches for exploring the parallel languages paradigm in Java environments. Research about the main parallel languages available in the literature is presented, in order to check the best solutions proposed by those languages. The work also presents an investigation about the Java tools available in the commercial market. Finally a new environment is proposed that makes some of the best resources of language Java available to the users by exploring the best solutions found in the literature.
43
Oliveira, Cristiano Bacelar de. "LALP+ : um framework para o desenvolvimento de aceleradores de hardware em FPGAs." Universidade de São Paulo, 2015. http://www.teses.usp.br/teses/disponiveis/55/55134/tde-30082016-160232/.
Full textAbstract:
Considerando a crescente demanda por desempenho em sistemas computacionais, a implementação de algoritmos diretamente em hardware com o uso de FPGAs (Field-programmable Gate Arrays) é uma alternativa que tem apresentado bons resultados. Porém, os desafios de programação envolvidos no uso de FPGAs, de tal forma a explorar eficientemente seus recursos, limita o número de desenvolvedores em função da predominância do paradigma de programação tradicionalmente sequencial, imposto pelas linguagens imperativas. Assim, este trabalho busca desenvolver mecanismos que facilitem o desenvolvimento com FPGAs, otimizando o uso de memória e explorando o paralelismo das operações. Este documento apresenta a tese de doutorado de título LALP+ : um framework para o desenvolvimento de aceleradores de hardware em FPGAs. Dado que a latência para leitura e escrita de dados têm sido um gargalo para algumas aplicações de alto desempenho, este trabalho trata do desenvolvimento de técnicas para geração de arquiteturas de hardware, considerando aspectos relativos ao mapeamento, gerenciamento e acesso à memória em arquiteturas reconfiguráveis. Para isto, o projeto desenvolvido utiliza como base a linguagem LALP, cujo foco é o tratamento de loops com a técnica de loop pipelining. As técnicas descritas nesta tese são empregadas no desenvolvimento do framework LALP+, o qual estende LALP com a implementação de novas características e funcionalidades, de forma a contribuir para o aumento do seu nível de abstração. As arquiteturas criadas utilizando LALP+ foram comparadas às geradas por ferramentas comerciais e acadêmicas, tendo apresentado, em média, um melhor desempenho, com redução do tempo de execução de 10;01, no melhor caso. Espera-se, por meio das contribuições aqui apresentadas, facilitar a implementação de produtos e projetos relacionados a aplicações de computação de alto desempenho que envolvam o uso de arquiteturas reconfiguráveis, promovendo uma maior absorção desta tecnologia.Considering the demand for high-performance in computer systems, the implementation of algorithms directly in hardware by using FPGAs (Field-programmable Gate Arrays) is an alternative that has shown good results. However, the number of developers is limited due to the challenges faced for efficiently programming FPGAs. In addition to that, developers are more used to the traditional sequential programming paradigm imposed by the imperative languages. This work seeks to develop mechanisms to facilitate the development with FPGAs, by optimizing memory usage and exploiting the parallelism of operations inside a loop. This document presents the doctoral thesis entitled LALP+ : a framework for developing FPGA-based hardware accelerators. Since the latency for reading and writing data have been a bottleneck for high performance applications, this work deals with the development of techniques for generation of hardware architectures, considering aspects related to mapping, management and memory access in reconfigurable architectures, using as basis the LALP language, which focuses on the treatment of loops with the technique of loop pipelining. The techniques described in this thesis are employed in the development of the LALP+ framework, which extends LALP by implementing new features and functionalities, in order to contribute to increase its abstraction level. LALP+ architectures were compared to ones generated by using academical and commercial tools, having presented, on average, better performance, with a execution time speedup of 10;01 for the best case. Thus, it is expected that the hereby presented contributions facilitate the implementation of products and projects related to high-performance computing applications with reconfigurable architectures, contributing for the use of such technology.
44
Fernandes, Andrino. "ABC-Pro." Florianópolis, SC, 2000. http://repositorio.ufsc.br/xmlui/handle/123456789/79191.
Full textAbstract:
Dissertação (mestrado) - Universidade Federal de Santa Catarina, Centro Tecnológico.Made available in DSpace on 2012-10-18T00:24:55Z (GMT). No. of bitstreams: 0Bitstream added on 2014-09-25T19:22:05Z : No. of bitstreams: 1 170455.pdf: 20277559 bytes, checksum: 3ed6a85c5430e0fcac288f2c4cc27704 (MD5)
Este trabalho tem como principal objetivo o desenvolvimento e a utilização do ABC-Pro, um software para o apoio ao ensino da lógica de programação. O ponto fundamental do trabalho é proporcionar facilidades para implementação de programas através de uma representação algorítmica. O aspecto pedagógico também faz parte desta abordagem. O conteúdo descritivo faz uma explanação do domínio do problema e as teorias de aprendizagem. O ambiente permite tratamento de erros numa linguagem apropriada para os iniciantes da programação, bem como possibilita aos alunos os conceitos e definições sobre o conteúdo básico necessário para elaboração de programas. O compilador como núcleo principal do ambiente é a origem de todo o trabalho e devidamente relatado. A aplicação deste trabalho teve como público alvo os alunos do Curso Técnico de Informática do CEFET/SC. Espera-se com este trabalho fornecer uma contribuição ao aluno proporcionando o aprendizado da lógica de programação e para o professor um instrumento que auxilie o acompanhamento e gerenciamento do processo de desenvolvimento cognitivo do aluno.
45
Benchimol, Isaac Benjamim. "Ferramentas de desenvolvimento para microcomputadores dedicados baseados em processadores 80386/80486." reponame:Repositório Institucional da UFSC, 1995. https://repositorio.ufsc.br/xmlui/handle/123456789/157916.
Full textAbstract:
Dissertação (mestrado) - Universidade Federal de Santa Catarina, Centro TecnologicoMade available in DSpace on 2016-01-08T19:34:45Z (GMT). No. of bitstreams: 1 99802.pdf: 2570350 bytes, checksum: d5cd4ff545ad452df301395ebf82b8ea (MD5) Previous issue date: 1995
Foi desenvolvido um conjunto de ferramentas que objetivam auxiliar o desenvolvimento, teste e depuração de softwares para microcomputadores dedicados que utilizam os recursos da arquitetura dos processadores Intel 80386/80486 disponíveis no modo protegido. As ferramentas implementadas permitem a utilização de um PC 386/486 compatível como ambiente de desenvolvimento, além dos compiladores mais populares para as linguagens de programação Assembly e C.
46
Landa, Torrejón Luis Ignacio. "Construcción de un editor de mapas para el juego "1814: la rebelión del Cuzco"." Bachelor's thesis, Pontificia Universidad Católica del Perú, 2017. http://tesis.pucp.edu.pe/repositorio/handle/123456789/9065.
Full textAbstract:
En el 2014, el grupo de investigación AVATAR lanzó su juego de estrategia en
tiempo real “1814: La rebelión del Cuzco”, y ahora desean expandir el contenido del
juego con nuevos mapas y niveles. Sin embargo, crear contenido de este tipo
requiere iniciar un ciclo de desarrollo extenso y costoso, el cual produce una
cantidad limitada de mapas.
Frente a esta necesidad, se propone un editor de mapas para el juego. Una
herramienta que permite crear una cantidad ilimitada de mapas y, a diferencia de un
algoritmo de generación de niveles, aprovecha la creatividad de los jugadores para
generar nuevo contenido e interés en el juego.
El editor se construyó siguiendo la estructura de un compilador que recibe como
entrada un lenguaje visual. Se elaboró primero una interfaz gráfica donde se edita
el mapa de forma intuitiva, el cual luego es procesado por el compilador y traducido
a una estructura de datos interpretable por el motor de juego. Por último, se realizó
una prueba con usuarios para validar la usabilidad del editor y el correcto
funcionamiento de los mapas editados.
Al finalizar el proyecto de fin de carrera se logró construir satisfactoriamente un
editor de mapas para “1814: La rebelión del Cuzco”, capaz de ser utilizado, tanto
por jugadores expertos como casuales, para crear fácilmente nuevos mapas y
luego integrarlos al juego.Tesis
47
Zorzo, Avelino Francisco. "Gramática transformacional com atributos." reponame:Biblioteca Digital de Teses e Dissertações da UFRGS, 1994. http://hdl.handle.net/10183/25176.
Full textAbstract:
A transformação entre linguagens, ou entre diferentes formatos de uma mesma linguagem, é um assunto que desperta interesse há vários anos e desta forma alguns trabalhos tem surgido para tentar automatizar o processo de transformação entre notações diferentes. Este trabalho descreve as Gramáticas Transformacionais empregados para descrever as transformag6es necessárias para converter uma notação em uma linguagem fonte (LF) para uma notação equivalente em uma linguagem objeto (LO). Nesta Gramática é embutido o conceito de Gramáticas de Atributos, criando assim as Gramáticas Transformacionais com Atributos (GTAs). Para validação das GTAs é apresentado um protótipo de ferramenta transformacional, que gera um tradutor, de LF para LO, a partir da descrição da gramática da LF e das regras de transformações para a LO. Tanto a LF quanto a LO são gramáticas do tipo LALR(1). Como objetivo de construir a ferramenta mais genérica possível, foram realizados estudos sobre três ferramentas, com as quais as transformações são possíveis. São elas: YACC, SINLEX e GG. É feita uma breve descrição destas três ferramentas e uma comparação com o protótipo implementado.Languages transformation or transformation among differents formats of the same language is a subject that , has had a lot of interest for t many years. Thus, research has been done aiming to automatize the proccess of transformation from one notation to another. This work describes the use of Transformation Grammars to describe the necessary transformations to convert from a Source Language (SL) notation to an equivalent Object Language (OL). The concept of Attribute Grammars is embbeded to these grammars, defining an Attributed Transformation Grammar (ATG). A transformation tool prototype to evaluate the ATGs is presented. This tool generates a translator from SL to OL using the SL grammar description and the corresponding transformation rules to the OL. Both the SL and OL are LALR(1) grammars. Studies on YACC, SINLEX and GG (tools wich allow transformations) were done trying to reach the most generic tool. A brief descriptions of these tools and a comparision with the prototype is presented.
48
Fabrício, Filho João. "Estratégias para exploração de sequências de transformações do compilador." Universidade Estadual de Maringá, 2017. http://repositorio.utfpr.edu.br/jspui/handle/1/2440.
Full textAbstract:
Os compiladores têm por função traduzir um programa em uma linguagem fonte para uma linguagem alvo, geralmente uma linguagem de máquina. Nessa tradução, encontrar a melhor correspondência entre as linguagens é um problema complexo, pelo tamanho do espaço de busca. Por tal complexidade, uma etapa de transformação de código é necessária, na qual algoritmos de transformação modificam o código tentando melhorá-lo sem alterar seu significado. O Problema de Seleção de Transformações (PST) consiste na busca das melhores transformações para um código de entrada, tal que o código final obtenha um bom desempenho. O estado-da-arte não possui estratégias que possibilitem soluções para o PST aplicáveis a usuários finais, pois o tempo de resposta é alto para tal aplicação. O objetivo deste trabalho é formular técnicas para encontrar efetivas sequências de transformações a serem aplicadas a um código de entrada, de forma a aumentar seu desempenho reduzindo o tempo de execução. Além disso, objetiva-se reduzir o tempo de resposta de forma que a solução para o PST se aproxime da utilização por usuários finais. Inicialmente, se explora a Variable Neighborhood Search (VNS) para solucionar o PST, compilando iterativamente cada código de entrada. A aplicação da VNS alcançou resultados até 15,72% melhores do que outra estratégia iterativa, conseguindo melhoria em todos os programas avaliados em relação ao melhor nível de transformação. Contudo, a compilação iterativa possui alto tempo de resposta. Assim, é necessário explorar técnicas de aprendizagem de máquina, que podem prover bons resultados baseadas em experiências anteriores do compilador. Dessa forma, esta dissertação explora diferentes caracterizações de programas para representar o conhecimento acumulado na aplicação de transformações, para então aplicar a um sistema de geração de código com Raciocínio Baseado em Casos (RBC), que escolhe determinada sequência para um programa de entrada. A representação do conhecimento é capaz de atingir 81% de proximidade do melhor resultado possível para os programas avaliados, enquanto o sistema RBC gera resultados 13,74% melhores do que o nível -O3, em um tempo de resposta 99% inferior ao de estratégias de compilação iterativa. A melhoria nas formas de recuperação de experiências anteriores conseguiu superar em 20,23% o desempenho obtido por outra estratégia comparada com um número de avaliações próximo.Compilers aims to translate a source language program to a target language, usually a machine language. Find the best correspondence between programming languages is a complex problem, due to the size of search space. Because of this complexity, a code transformation step is needed, where transformation algorithms modify the code, trying to improve it without semantic alterations. Despite, the result of the application of these algorithms depends on code particularities. The Transformations Selection Problem (TSP) consists of the search for the best transformations to an input code, such that target code achieves a good performance. The state-of-art does not have strategies that allow the application of TSP solutions to final users, because the response time is very high to this. This work aims to formulate techniques to find effective transformations sequences to be applied to an input code, in a way to increase programs performance reducing its execution time. Furthermore, another objective is to reduce the compiler response time, to approximate a TSP solution to final users application. Initially, the metaheuristic Variable Neighborhood Search (VNS) is explored to solve TSP, compiling iteratively each input code. VNS achieved results up to 15.72% better than another iterative strategy, reaching improvement for all evaluated programs compared to the best compiler transformation level. However, the iterative compilation demands a high response time. Therefore, it is necessary to explore machine learning techniques, which can provide good results based on compiler previous experiences, with a cost of an initial training phase. Thus, this work explores different program characterizations to represent the cumulated knowledge on transformations application, to formulate a code generation system with Case-Based Reasoning (CBR), which chooses certain sequence to an input program. The knowledge representation is capable to reach 81% of proximity of the best possible result to evaluated programs, while the CBR system generates results 13.74% better than -O3 level, on a response time 99% lower than iterative compilation techniques. The improvement of previous experiences recovering method obtained performances over 20.23% compared to another strategy with a close evaluations number.
49
Pires, João Carlos Cordeiro. "Porting of GNU linker for the EVP DSP." Master's thesis, Universidade de Aveiro, 2014. http://hdl.handle.net/10773/14053.
Full textAbstract:
Mestrado em Engenharia de Computadores e TelemáticaNowadays, with the ubiquitous presence of mobile devices, modems play a relevant role. The EVP is a vector processor used by Ericsson on its 2G, 3G and 4G modems. Due to size, weight and power constraints, mobile devices have limited power sources, and because of that the hardware must be power efficient. The processors used in this type of devices have multiple power consumption states. If a processor is in a idle state i.e. without code to execute, it can switch off and consume less power. Moreover, if it is known beforehand that the processing takes less time than available, the processor can be set to a lower frequency (and lower voltage level), executing the same amount of work, but consuming considerable less energy. With this dynamic power consumption the autonomy of the devices is extended, because the processor can be in a reduced power consumption state most of the time. One way to maximize the time during which the processor stays in a reduced power consumption state is through the execution of optimized code. This can be achieved through manual code optimization, or by letting the compiler apply optimizations on the code. Link Time Optimization (LTO) is a compilation technique that tries to expand the optimizations scope by joining the input files and compile them as a unique file. Using this technique the compiler has more information during the optimization phase and should be able to do better decisions about the optimizations to apply. The team responsible for the development of Embedded Vector Processor (EVP) wanted to evaluate the benefits of LTO. To be able to implement and evaluate LTO it was necessary to migrate the GNU linker to support EVP and enable LTO compilation on the EVP backend of GNU Compiler Collection (GCC). This dissertation reports this work, including the necessary concepts to understand the problem addressed, how was added EVP support in the GNU linker, and the necessary step to enable LTO compilation on GCC. Also it will be presented and analysed the performance improvements of using LTO. The LTO compilation presents mixed results some of the test cases have a small performance improvements, and other present a small performance degradation. This was kind is expected because of the organization of the test code. It is composed by several files that do not have dependencies between them, in this situation the LTO compilation do not present much benefits.
Hoje em dia, com a ubiquidade dos dispositivos móveis, os modems desempenham um papel relevante. O EVP e um processador vectorial usado pela Ericsson nos seus modems 2G, 3G e 4G. Devido às condicionantes ao nível de tamanho, peso e energia, os dispositivos móveis tem fontes de energia limitadas, e por isso o hardware tem de ser energeticamente eficiente. Os processadores usados neste tipo de dispositivos, tem múltiplos estados de consumo. Se um processador estiver inactivo i.e. sem ter código a ser executado, o processador pode ser desligado passando a consumir menor energia. Mais ainda se for conhecido de antemão que o processamento demora menos tempo que o disponível, o processador pode reduzir a sua frequência (e a sua tensão), realizando a mesma quantidade de trabalho mas consumindo consideravelmente menos energia. Com o consumo energético dinâmico, a autonomia dos dispositivos e estendida, porque o processador pode estar grande parte do tempo num estado de baixo consumo energético. Uma maneira de maximizar o tempo que o processador está num estado de baixo consumo energético e através do uso de código optimizado. Este pode ser obtido através de optimização manual, ou deixando o compilador aplicar as otimiza ções. LTO é uma técnica de compilação que tenta expandir o âmbito das optimizações através da junção dos cheiros de entrada e compila-los como um s o. O uso desta técnica permite que o compilador tenha mais informação durante a fase de optimização e deve conseguir tomar melhores decisões sobre as optimizações a aplicar. A equipa responsável pelo desenvolvimento do EVP queria avaliar os benefícios do LTO. Para implementar e avaliar o LTO era preciso adicionar suporte para o EVP ao GNU linker e activar o LTO no GCC específico para o EVP. Esta dissertação reporta o trabalho realizado, incluindo os conceitos necessários para perceber o problema, como foi adicionado o suporte para o EVP no GNU linker e os passos necessários para activar a compilação LTO no GCC. Vão ser também apresentadas e analisadas as alterações de desempenho quando o LTO e usado. A compilação LTO apresenta resultados ambíguos, em alguns dos casos de teste houve pequenos aumentos de desempenho e noutros casos pequenas diminuições de desempenho. Estes resultados eram mais ou menos esperados, devido a organização do código de teste. Este é composto por diversos cheiros que não tem dependências entre si, nestas situações a compilação LTO não traz praticamente nenhuns benefícios.
50
Porto, Lucas Faria. "LALPC: uma ferramenta para compilação de programas em C para exploração do paralelismo de loops em FPGAs." Universidade Federal de São Carlos, 2015. https://repositorio.ufscar.br/handle/ufscar/603.
Full textAbstract:
Made available in DSpace on 2016-06-02T19:06:23Z (GMT). No. of bitstreams: 1
6777.pdf: 1533148 bytes, checksum: 25830198cf2d72379370c2466a0688cc (MD5)
Previous issue date: 2015-02-04The physical limitations of silicon forced the industry to develop solutions that exploit the processing power of combining several general purpose processors. Even complex supercomputers that have multiple processors, they are still considered to inefficient processes that require large amounts of arithmetic operations using floating point data. Reconfigurable computing is gaining more space to have a performance close to a specific purpose devices (ASIC), and yet keep the flexibility provided by the architecture of general purpose processors. However, the complexity of hardware description languages often becomes a problem to the development of new projects. Tools for high-level synthesis have become more popular, they allow the transformation code in high-level hardware simply and quickly. However, solutions found in current tools generate simple hardware that does not exploit the techniques to improve the pipeline in hardware. This paper presents the development of techniques to exploit processing parallelism of the reconfigurable devices through programs described in language C. These techniques identify loops and improve the performance in hardware. As a result, we have improved in the high-level synthesis process generating optimized hardware.
A limitação física do silício forçou a indústria a desenvolver soluções que explorassem o poder de processamento de combinação de vários processadores de propósito geral. Mesmo os supercomputadores complexos que dispõem de vários processadores, eles ainda são considerados ineficientes para processamentos que exigem grandes quantidades de operações aritméticas utilizando dados em ponto flutuante. A computação reconfigurável vem ganhando cada vez mais espaço por ter um desempenho próximo aos dispositivos de propósito específico (ASIC), e ainda assim, manter a flexibilidade proporcionada pela arquitetura dos processadores de propósito geral. Entretanto, a complexidade das linguagens de descrição de hardware se torna muitas vezes uma barreira para o desenvolvimento de novos projetos. Ferramentas de síntese de alto nível vem se popularizando, elas permitem a transformação de códigos em alto nível em hardware de maneira simples e rápida. Entretanto, soluções encontradas nas ferramentas atuais, geram hardware simples que não exploram as técnicas que permitam melhorar o pipeline em hardware. Este trabalho apresenta o desenvolvimento de técnicas que permitem explorar o poder do paralelismo nos dispositivos reconfiguráveis por meio de programas descritos em uma linguagem C. Essas técnicas identificam laços de repetição e melhoram o desempenho em hardware. Como resultado, temos a melhora no processo de síntese de alto nível gerando hardware otimizado.