Orientadores: Paulo Cesar Centoducatte, Guido Costa Souza de Araujo / Dissertaçã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

Denna rapport redogör för en webbapplikation med ett användargränssnitt som visar Preems volymdifferenser. Syftet med arbetet var främst utveckla en enklare metod för att spåra oförklarliga differenser i Preems lagerkontroll. Rapporten tar även upp grundläggande metoder för att anpassa webbapplikationer för olika företagsmodeller. Det resulterande systemet blev en webbapplikation med ett användargränssnitt för lagerkontroll, där man enkelt kan navigera. Webbapplikationen reagerar på varningar och genererar automatiskt anpassade tabeller/grafer. / This report describes a web application with a user interface that displays Preem volume differences. The main purpose of this work was to develop an easier method for tracking unexplained differences in Preem’s inventory control. The report also discusses basic approaches for adapting web application for different business models.   The resulting system is a web application with a user interface for inventory control, where you can easily navigate. The web application also responds to warnings and automatically generates adaptive tables/graphs.

This thesis presents a new security policy enforcer designed for securing parallel computation on CUDA GPUs. We show how the very features that make a GPGPU desirable have already been utilized in existing exploits, fortifying the need for security protections on a GPGPU. An aspect weaver was designed for CUDA with the goal of utilizing aspect-oriented programming for security policy enforcement. Empirical testing verified the ability of our aspect weaver to enforce various policies. Furthermore, a performance analysis was performed to demonstrate that using this policy enforcer provides no significant performance impact over manual insertion of policy code. Finally, future research goals are presented through a plan of work. We hope that this thesis will provide for long term research goals to guide the field of GPU security.

L'analyse statique des programmes permet d'étudier les comportements possibles des programmes sans les exécuter. Les analyseurs statiques sont employés par exemple pour garantir que l'exécution d'un programme ne peut pas produire d'erreurs. Ces outils d'analyse étant eux-mêmes des programmes, ils peuvent être incorrects. Pour accroître la confiance que l'on peut accorder aux résultats d'une telle analyse, nous étudions dans cette thèse comment on peut formellement établir la correction de l'implantation d'un tel analyseur statique. En particulier, nous construisons au moyen de l'assistant à la preuve Coq des interpréteurs abstraits et prouvons qu'ils sont corrects ; c'est-à-dire nous établissons formellement que le résultat de l'analyse d'un programme caractérise bien toutes les exécutions possibles de ce programme. Ces interpréteurs abstraits s'intègrent, dans la mesure du possible, au compilateur vérifié CompCert, ce qui permet de garantir que les propriétés de sûreté prouvées sur le code source d'un programme sont aussi valides pour la version compilée de ce programme. Nous nous concentrons sur l'analyse de programmes écrits dans des langages de bas niveau. C'est-à-dire des langages qui ne fournissent que peu d'abstractions (variables, fonctions, objets, types…) ou des abstractions que le programmeur a loisir de briser. Cela complexifie la tâche d'un analyseur qui ne peut pas s'appuyer sur ces abstractions pour être précis. Nous présentons notamment comment reconstruire automatiquement le graphe de flot de contrôle de programmes binaires auto-modifiants et comment prouver automatiquement qu'un programme écrit en C (où l'arithmétique de pointeurs est omniprésente) ne peut pas produire d'erreurs à l'exécution. / Static analysis of programs enables to study the possible behaviours of programs without running them. Static analysers may be used to guarantee that the execution of a program cannot result in a run-time error. Such analysis tools are themselves programs: they may have bugs. So as to increase the confidence in the results of an analysis, we study in this thesis how the implementation of static analysers can be formally proved correct. In particular, we build abstract interpreters within the Coq proof assistant and prove them correct. Namely, we formally establish that analysis results characterize all possible executions of the analysed program. Such abstract interpreters are integrated to the formally verified CompCert compiler, when relevant ; this enables to guarantee that safety properties that are proved on source code also hold for the corresponding compiled code. We focus on the analysis of programs written in low-level languages. Namely, languages which feature little or no abstractions (variables, functions, objects, types…) or abstractions that the programmer is allowed to break. This hampers the task of a static analyser which thus cannot rely on these abstractions to yield precise results. We discuss in particular how to automatically recover the control-flow graph of binary self-modifying programs, and how to automatically prove that a program written in C (in which pointer arithmetic is pervasive) cannot produce a run-time error.

[pt] Expressões regulares são um formalismo utilizado para descrever linguagens regulares e compõem a base de diversas bibliotecas de casamento de padrão. No entanto, existem determinados padrões úteis que são complexos ou impossíveis de serem descritos com expressões regulares puras. Devido a essas limitações, linguagens de script modernas disponibilizam bibliotecas de casamento de padrões baseadas em regexes, isto é, extensões de expressões regulares compostas, principalmente, por construções ad-hoc que focam em problemas específicos. Apesar de serem muito úteis na prática, os regexes possuem implementações complexas e distantes do formalismo original de expressões regulares. Parsing Expression Grammars (PEG) são uma alternativa formal para reconhecer padrões e possuem mais expressividade que expressões regulares sem necessitar de contruções ad-hoc. O objetivo deste trabalho é estudar formas de conversão de regexes para PEGs. Para isso, estudamos as implementações atuais de regexes e mostramos a conversão de algumas construções para PEGs. Por fim, apresentamos uma implementação da conversão de regexes para PEGs para a linguagem Lua. / [en] Regular expressions are a formalism used to describe regular languages and form the basis of several pattern-matching libraries. However, many interesting patterns either are difficult to describe or cannot be described by pure regular expressions. Because of these limitations, modern scripting languages have pattern matching libraries based on regexes, ie, extensions of regular expressions mainly composed by a set of ad-hoc constructions that focus on specific problems. Although very useful in practice, these implementations are complex and distant from the original formalism of regular expressions. Parsing Expression Grammars (PEG) are a formal alternative to recognize patterns and it is much more expressive than pure regular expressions and does not need use ad-hoc constructions. The goal of this work is to study the convertion of regexes to PEGs. To accomplish this task, we studied the current implementations of regexes and show how to convert some constructions to PEGs. Finally, we present an implementation that convert regexes to PEGs for the Lua language.

To define a language completely, it is necessary to define both its syntax and semantics. If these definitions are in a suitable form, the parser and code-generator of a compiler, respectively, can be generated from them. This thesis addresses the problem of syntax definition and automatic parser generation.

Protecting confidential information from improper disclosure is a fundamental security goal. While encryption and access control are important tools for ensuring confidentiality, they cannot prevent an authorized system from leaking confidential information to its publicly observable outputs, whether inadvertently or maliciously. Hence, secure information flow aims to provide end-to-end control of information flow. Unfortunately, the traditionally-adopted policy of noninterference, which forbids all improper leakage, is often too restrictive. Theories of quantitative information flow address this issue by quantifying the amount of confidential information leaked by a system, with the goal of showing that it is intuitively “small” enough to be tolerated. Given such a theory, it is crucial to develop automated techniques for calculating the leakage in a system. This dissertation is concerned with program analysis for calculating the maximum leakage, or capacity, of confidential information in the context of deterministic systems and under three proposed entropy measures of information leakage: Shannon entropy leakage, min-entropy leakage, and g-leakage. In this context, it turns out that calculating the maximum leakage of a program reduces to counting the number of possible outputs that it can produce. The new approach introduced in this dissertation is to determine two-bit patterns, the relationships among pairs of bits in the output; for instance we might determine that two bits must be unequal. By counting the number of solutions to the two-bit patterns, we obtain an upper bound on the number of possible outputs. Hence, the maximum leakage can be bounded. We first describe a straightforward computation of the two-bit patterns using an automated prover. We then show a more efficient implementation that uses an implication graph to represent the two- bit patterns. It efficiently constructs the graph through the use of an automated prover, random executions, STP counterexamples, and deductive closure. The effectiveness of our techniques, both in terms of efficiency and accuracy, is shown through a number of case studies found in recent literature.

We introduce a class of program editors that present a program using a rich set of transformations; we call these kinds of editors composable presentation editors. Proper use of these kinds of editors appears to lead to more expressive programs-programs whose structure are aligned with the problem they are trying to solve. By default, the composable presentation editor presents program elements textually as concrete syntax and enables typical editor commands on the program. Metadata on program elements control how the transformations are applied. Customized metadata can re-order, pictorialize, collapse, duplicate, or expand the displayed form of program elements and can additionally alter the available editor commands. We have developed a set of presentation techniques to be used by presentation designers (i.e., the programmers who design how a program is presented in the editor. These techniques relate to well-understood programming language design, editor design, and programming best-practices techniques including scoping, higher order functions, refactoring, prettyprinting, naming conventions, syntax highlighting, and text hovers. We introduce two implementations of composable presentation editors and a number of examples showing how programs can be made more expressive when presentation techniques are properly used. The first implementation is the ETMOP, an open editor, where a metaobject protocol is provided that allows language and editor designers to customize the way program elements are displayed. These customizations are called presenta- tion extensions and the corresponding presentation extension protocol acts in a way similar to the way that syntax macros extend the syntax of a language. The second implementation is Embedded CAL, a closed editor that uses these presentation techniques to embed one language (CAL) inside a host language (Java) through the use of presentation techniques, without changing the syntax or compiler of either language. / Science, Faculty of / Computer Science, Department of / Graduate

It is an acknowledged fact that many novice programmers experience difficulty in the process of learning to program. One of the contributing factors to this difficulty is the Program Development Environment (PDE). Professional-PDEs are those developed specifically for professional programmers, but are often used by educational institutions in the instruction of programming. It has long been accepted that such environments are inappropriate in the instruction of programming due to unnecessary complexity and lack of support for novice programmers in the learning process. Numerous pedagogical-PDEs supporting the mechanics of programming have been developed in response to this. A review of literature, however, indicates that very limited empirical studies comparing pedagogical-PDEs and professional-PDEs have been conducted. The current study investigates whether there are measurable benefits to using a pedagogical-PDE supporting the mechanics of programming in the instruction of programming instead of a professional-PDE. A comparative study of this nature requires a representative pedagogical-PDE and representative professional-PDE be compared with one another. The first part of the current study determines a set of requirements that a pedagogical- PDE should adhere to based on literature. A set of representative features for a pedagogical-PDE is derived by examining the features of existing PDEs in conjunction with the set of requirements. Based on these features, a pedagogical-PDE, known as SimplifIDE, is developed that implements the representative set of features and that meets are the requirements for a pedagogical-PDE. The second part of the current study is the specification and administration of an empirical experiment in which SimplifIDE and Borland© DelphiTM are compared with one another. A holistic approach in determining the differences between the PDEs is taken and three main areas are examined, namely academic performance, perceptions and programming behavior.

M.Sc. (Computer Science) / Please refer to full text to view abstract