Dissertação (mestrado)—Universidade de Brasília, Instituto de Ciências Exatas, Departamento de Ciência da Computação, 2006. / Submitted by Fernanda Weschenfelder (nandaweschenfelder@gmail.com) on 2009-11-03T16:07:34Z No. of bitstreams: 1 Dissertacao_Lorena Brasil Cirilo Passos_20061207_CIC.pdf: 1280461 bytes, checksum: 5d78db2dd313197338c3e8ca3e9e811f (MD5) / Approved for entry into archive by Gomes Neide(nagomes2005@gmail.com) on 2010-02-08T18:32:57Z (GMT) No. of bitstreams: 1 Dissertacao_Lorena Brasil Cirilo Passos_20061207_CIC.pdf: 1280461 bytes, checksum: 5d78db2dd313197338c3e8ca3e9e811f (MD5) / Made available in DSpace on 2010-02-08T18:32:57Z (GMT). No. of bitstreams: 1 Dissertacao_Lorena Brasil Cirilo Passos_20061207_CIC.pdf: 1280461 bytes, checksum: 5d78db2dd313197338c3e8ca3e9e811f (MD5) Previous issue date: 2006-12-07 / Nesta dissertação, é apresentada a avaliação de desempenho de uma implementação paralela de um algoritmo seqüencial do integrador simplético para simular a evolução temporal de sistemas auto-gravitantes. Este algoritmo foi paralelizado e posteriormente implementado na linguagem C, utilizando-se dois paradigmas de programação paralela: a troca de mensagens empregando-se a biblioteca MPICH 1.2.6 e a memória compartilhada distribuída com o middleware JIAJIA. Um cluster homogêneo de PCs foi o ambiente em que os testes de execução dos programas foram realizados. Um ambiente heterogêneo também foi utilizado para a realização de medidas de desempenho com um balanceamento empírico de carga, uma vez que a montagem deste tipo de sistema paralelo é prática freqüente entre usuários que necessitam de um maior poder computacional. Para quantificar o desempenho da execução paralela das duas implementações distintas, foram realizados as medições dos tempos de execução e os cálculos dos speedups obtidos. Para mensurar o tempo de execução, foi inserida em cada um dos códigos-fonte a instrução assembly rdtsc que fornece ciclos de clock contabilizados em um registrador de hardware. Para o caso da implementação MPI, também foram realizadas medições de tempo de execução por meio da porta paralela utilizando-se a ferramenta PM2P. _______________________________________________________________________________ ABSTRACT / In this work it is presented the performance evaluation of a parallel implementation for the sympletic integrator to simulate the temporal evolution of a self-gravitating system. The algorithm of the sympletic integrator was parallelized and the source code was written in the C programming language. Two parallel programming paradigms were employed: message passing, using the MPICH 1.2.6 library specification, and distributed shared memory, using the JIAJIA middleware. A homogeneous cluster of PCs was used to run the program tests. Due to the fact that users that need greater computational power tend to build heterogeneous computational environments, we also used a heterogeneous parallel system to take the performance measures using an empirical load balancing. To quantify the parallel execution performance of the programs, execution time measures were taken and the speedups achieved were calculated. To measure the execution time, it was inserted into the source codes the assembly instruction rdtsc, which counts the clock cycles in hardware register. For the MPI implementation version, execution time measures made by the parallel port were also taken using a tool called PM2P.

Este trabalho apresenta o desenvolvimento de uma linguagem para descrição simplificada de algoritmos paralelos, um tradutor e um simulador de rede. Com vistas à avaliação de desempenho, a linguagem permite uma prototipagem fácil e abrangente para descrever vários tipos de programas paralelos, envolvendo estruturas de controle, repetição e as partes de comunicação e computação. Para interpretar o código escrtio na linguagem, foi desenvolvido um tradutor que traduz o código simplificado descrito pela linguagem desenvolvida, gerando código C++. O simulador de rede computa os tempos envolvidos nas comunicações. O simulador interage com o código gerado pelo tradutor. Para validação foram utilizados alguns programas de testes e resultado da simulação comparado com o da execução em um cluster de computadores pessoais. / This work presents the development of a language for simplified description of parallel algorithms, a language translator and a network simulator. The language aims to allow an easy parallel program prototyping for performance evaluation purposes and aims to be enough comprehensive to describe several kinds of parallel programs including execution control structures, repetition communication and computation parts. A translator that translates the simplified code described by the language was developed producing C++ code. A network simulator computes the communication times. The simulator interacts with the code produced by the translator. For validation some tests programs were used and the simulation results compared with the execution times in a cluster of personal computers.

Este trabalho descreve um projeto simples de gerenciamento de clusters que apresenta uma interface de usuário para as tarefas mais comuns de uso e gerenciamento de um cluster utilizado como máquina paralela. A partir do estudo de vários softwares existentes hoje, o sistema projetado foi adequado às necessidades do cluster do Laboratório de Processamento Paralelo Aplicado do Instituto de Física de São Carlos. O sistema é baseado em páginas HTML e scripts CGI. O uso de HTML e CGI se demonstrou apropriado para o desenvolvimento desse tipo de sistemas. / This work describes a simple cluster management system that operates as a user interface for some common user and manager tasks performed on a cluster used as parallel machine. We studied some cluster management systems from the literature and then designed a system with the needs of our research laboratory in mind. The system was implemented using HTML pages and CGI scripts. The use of HTML and CGI was found adequate for this type of systems.

O presente trabalho apresenta o desenvolvimento de um sistema de Visão Artificial inteligente visando uma maior velocidade de processamento, um menor custo e aumento na produtividade industrial. Para o desenvolvimento do sistema foi utilizado o computador paralelo SPP3 desenvolvido no LCAD (Laboratório de Computação de Alto Desempenho) do ICMSC (Instituto de Ciências e Matemática de São Carlos) que utiliza uma arquitetura paralela MIMD com memória distribuída e a uma rede de comunicação de alta velocidade do tipo Myrinet [TRINDADE, 1994]. Este trabalho de tese teve como proposta desenvolver um sistema de visão em tempo real. Para atender os objetivos propostos citados, realizou-se de forma inédita a utilização de métodos estatísticos na extração do mínimo de características naturais (textura) e artificiais (histograma), invariantes à transformações geométricas, que definam a cena (ou objeto), para formar os vetores de atributos destinados ao treinamento e aprendizagem de redes neurais, utilizando ainda a técnica de invariância pelo treinamento. E para melhorar ainda mais a eficiência recorreu-se a utilização do paralelismo de hardware e software, proporcionando uma aplicação para multicomputadores / The present work presents the development of an intelligent Artificial Vision system seeking larger processing speed, smaller cost and increase in the industrial productivity. For the development of the system, a parallel computer was used, the SPP3 developed in LCAD (Laboratory of Computation of High Performance computing) of the ICMSC (Institute of Sciences and Mathematics of São Carlos). The SPP3 uses a parallel architecture MIMD with distributed memory and the a high-speed Myrinet communication network [TRINDADE, 1994]. This Thesis\'s work has with plan the development of a vision\'s sistem in real time. To attend the objetives cited, it was realized of original form, the utilization of statistical methods in extraction of less natural feature (texture) and artificial (histogram) invariants for geometrics transformations, that define the scene (or objects), to form the attributes vectors destinated for training and learning of neural networks, still using the invariants technical for training. And to improve more the eficient have recourse to use parallelism of hardware and software, giving a application to multicomputers

O presente trabalho tem como objetivo explorar as dificuldades bem como os benefícios da utilização de arquiteturas Streams para a simulação de eventos hidrológicos baseados nas equações de águas rasas. Pra tal, é criado embasamento sobre modelagem hidrológica e os algumas classes de modelos existentes, arquiteturas heterogêneas e mais especificamente do modelo bidimensional usado baseado nas equações de Saint-Venan. Com isso é construida a linha de tempo referente às otimizações aplicadas ao modelo inicialmente serial até sua versão otimizada para GPUs, exibindo cada passo tomado em forma de algoritmo para chegar ao objetivo. Com estas otimizações foi obtido um speedup de quatro vezes para pequenas áreas e de 10 vezes com uma resolução média para uma grande área com um alto nível de detalhamento, quando comparado com uma versão de 24 threads. / This study aims to explore the difficulties and the benefits of using Streams architectures for the simulation of hydrological events based on shallow water equations. For this purpose, is created foundation on hydrological modeling and some classes of existing models, heterogeneous architectures, and more specifically the two-dimensional model based on the equations used Saint-Venan. A timeline is constructed relating the applied optimizations beginning from the first serial model optimized for a GPU version showing each step taken in the form of an algorithm to reach the best performance. With these optimizations a speedup about 4 times was obtained for small areas and 10 times with a middle level of detailing for a large area with a high level of detailing. These results were produced comparing the GPU performance with a CPU and 24 threads version.

Devido as limitações de consumo energético impostas a supercomputadores, métricas de eficiência energética estão sendo usadas para analisar aplicações paralelas desenvolvidas para computadores de alto desempenho. O objetivo é a redução do custo energético dessas aplicações. Algumas estratégias de redução de consumo energética consideram a aplicação como um todo, outras reduzem ajustam a frequência dos núcleos apenas em certas regiões do código paralelo. Fases de balanceamento de carga ou de comunicação bloqueante podem ser oportunas para redução do consumo energético. A análise de eficiência dessas estratégias é geralmente realizada com metodologias tradicionais derivadas do domínio de análise de desempenho. Uma metodologia de grão mais fino, onde a redução de energia é avaliada para cada região de código e frequência pode lever a um melhor entendimento de como o consumo energético pode ser minimizado para uma determinada implementação. Para tal, os principais desafios são: (a) a detecção de um número possivelmente grande de regiões paralelas; (b) qual frequência deve ser adotada para cada região de forma a limitar o impacto no tempo de execução; e (c) o custo do ajuste dinâmico da frequência dos núcleos. O trabalho descrito nesta dissertação apresenta uma metodologia de análise de desempenho para encontrar, dentre as regiões paralelas, os melhores candidatos a redução do consumo energético. (Cotninua0 Esta proposta consiste de: (a) um design inteligente de experimentos baseado em Plackett-Burman, especialmente importante quando um grande número de regiões paralelas é detectado na aplicação; (b) análise tradicional de energia e desempenho sobre as regiões consideradas candidatas a redução do consumo energético; e (c) análise baseada em eficiência de Pareto mostrando a dificuldade em otimizar o consumo energético. Em (c) também são mostrados os diferentes pontos de equilíbrio entre desempenho e eficiência energética que podem ser interessantes ao desenvolvedor. Nossa abordagem é validada por três aplicações: Graph500, busca em largura, e refinamento de Delaunay. / Due to energy limitations imposed to supercomputers, parallel applications developed for High Performance Computers (HPC) are currently being investigated with energy efficiency metrics. The idea is to reduce the energy footprint of these applications. While some energy reduction strategies consider the application as a whole, certain strategies adjust the core frequency only for certain regions of the parallel code. Load balancing or blocking communication phases could be used as opportunities for energy reduction, for instance. The efficiency analysis of such strategies is usually carried out with traditional methodologies derived from the performance analysis domain. It is clear that a finer grain methodology, where the energy reduction is evaluated per each code region and frequency configuration, could potentially lead to a better understanding of how energy consumption can be reduced for a particular algorithm implementation. To get this, the main challenges are: (a) the detection of such, possibly parallel, code regions and the large number of them; (b) which frequency should be adopted for that region (to reduce energy consumption without too much penalty for the runtime); and (c) the cost to dynamically adjust core frequency. The work described in this dissertation presents a performance analysis methodology to find the best parallel region candidates to reduce energy consumption. The proposal is three folded: (a) a clever design of experiments based on screening, especially important when a large number of parallel regions is detected in the applications; (b) a traditional energy and performance evaluation on the regions that were considered as good candidates for energy reduction; and (c) a Pareto-based analysis showing how hard is to obtain energy gains in optimized codes. In (c), we also show other trade-offs between performance loss and energy gains that might be of interest of the application developer. Our approach is validated against three HPC application codes: Graph500; Breadth-First Search, and Delaunay Refinement.

A maior parte dos mecanismos em processadores superescalares atuais usam granularidade de instrução para criar ou caracterizar especulações, tais como predição de desvios ou prefetchers. No entanto, muitas das características das instruções podem ser obtidas ao analisar uma granularidade mais grossa, o bloco básico de código, aumentando a quantidade de código coberta em um espaço similar de armazenamento. Adicionalmente, códigos podem ser analisados mais precisamente e prover uma variedade maior de informação ao observar diferentes tipos de instruções e suas relações. Devido a estas vantagens, a análise no nível de blocos pode fornecer mais oportunidades para mecanismos que necessitam desta informação. Por exemplo, é possível integrar informações de desvios mal previstos e acessos a memória para gerar informações mais precisas de quais acessos a memória oferecem melhor desempenho ao serem priorizados. Nesta tese propomos o Block-Level Architecture Profiler (BLAP) (Block Level Architecture Profiler), um mecanismo em hardware que caracteriza gargalos no nível microarquitetural, tal como loads delinquentes, desvios de difícil previsão e contenção nas unidades funcionais. O BLAP trabalha no nível de bloco básico, apenas detectando e fornecendo informações que podem ser usada para otimizar tais gargalos. Um mecanismo para a remoção de prefetches e uma política de controlador de memória DRAM foram criados para usar a informação criada pelo BLAP e demonstrar seu potencial. Juntos, estes mecanismos são capazes de melhorar o desempenho do sistema em até 17.39% (3.9% em média). Nosso método mostrou também ganhos médios de 13.14% quando avaliado com uma pressão na memória mais alta devido a prefetchers mais agressivos. / Most mechanisms in current superscalar processors use instruction granularity information for speculation, such as branch predictors or prefetchers. However, many of these characteristics can be obtained at the basic block level, increasing the amount of code that can be covered while requiring less space to store the data. Moreover, the code can be profiled more accurately and provide a higher variety of information by analyzing different instruction types inside a block. Because of these advantages, block-level analysis can offer more opportunities for mechanisms that use this information. For example, it is possible to integrate information about branch prediction and memory accesses to provide precise information for speculative mechanisms, increasing accuracy and performance. We propose a BLAP, an online mechanism that profiles bottlenecks at the microarchitectural level, such as delinquent memory loads, hard-to-predict branches and contention for functional units. BLAP works at the basic block level, providing information that can be used to reduce the impact of these bottlenecks. A prefetch dropping mechanism and a memory controller policy were developed to use the profiled information provided by BLAP. Together, these mechanisms are able to improve performance by up to 17.39% (3.90% on average). Our technique showed average gains of 13.14% when evaluated under high memory pressure due to highly aggressive prefetch.

Made available in DSpace on 2014-06-12T17:35:12Z (GMT). No. of bitstreams: 2 arquivo5391_1.pdf: 5090704 bytes, checksum: 8579bb353f3397d7c9f8d6e90e505f32 (MD5) license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5) Previous issue date: 2008 / O processo de digitalização de documentos de maneira automática geralmente resulta em imagens com características indesejáveis como orientação errada, inclinação incorreta das linhas do texto e até mesmo a presença de ruídos causados pelo estado de conservação, integridade física e presença ou ausência de poeira no documento e partes do scanner. O simples processamento de cada imagem é efetuado em poucos segundos, a sua transcrição ou busca de palavras-chave para indexação necessita vários segundos de processamento. O lote produzido por um único scanner de linha de produção pode levar dias para ser filtrado, dependendo da capacidade de processamento do computador utilizado. Faz-se necessário distribuir tal tarefa para que o processamento das imagens acompanhe a taxa de digitalização. Esta tese analisa a viabilidade da computação paralela em cluster e grades para o processamento de grandes quantidades de imagens de documentos digitalizados. Diferentes cenários de configuração de computadores e de distribuição de tarefas foram analisados, sob o ponto de vista do processamento das tarefas e do tráfego de rede gerado durante o processamento

Orientador: Ivanil Sebastião Bonatti / Tese (doutorado) - Universidade Estadual Campinas, Faculdade de Engenharia Eletrica / Made available in DSpace on 2018-07-21T03:46:20Z (GMT). No. of bitstreams: 1 Souza_KleberXavierSampaiode_D.pdf: 8780456 bytes, checksum: 479a505e0aef8ae02521f765066f0d36 (MD5) Previous issue date: 1996 / Resumo: Neste trabalho, a Plataforma Distribuída de Agregados de Atores é proposta para a implementação de serviços de gerência na Rede de Gerência de Telecomunicações (TMN), em um ambiente de rede de alta velocidade, como o Modo de Transferência Assíncrono 1 (ATM). As principais contribuições desta pesquisa são: a análise dos requisitos necessários à gerência de redes de alta velocidade, e a proposição de um modelo baseado em filas com prioridades: Extensão deste modelo para aplicação à Rede TMN, anexando mecanismos de transparência necessários à integração dos vários componentes funcionais da arquitetura TMN: Demonstração da adequação do modelo estendido à implementação de serviços em redes inteligentes (IN), confirmando a tendência de integração entre TMN e IN; Proposição da aplicação da Teoria de Atores na implementação do modelo proposto, mediante extensão da teoria básica incluindo: filas de eventos prioritários, conceito de Agregados (para Transparência de Localização) e mecanismo de Transparência de Acesso, usando a linguagem ASN.1; e a construção de um núcleo de suporte à implementação de Agregados de Atores, utilizando facilidades de "threads" de controle, ambiente ISODE (ISSO Development Environment) e a linguagem de programação C++ / Abstract: ln this work, the Distributed Actor Aggregates PIatform is proposed to impIement services in the TeIecommunications Management Network (TMN) in high speed network environment, such as synchronous Transfer Mode (ATM). The main contributions of this thesis are: the requirements analysis of management in high speed networks, and the proposition of a model based on priority queues; Extension of the model for application to TMN Networks, adding transparency mechanisms necessary to integrate TMN functional components; Demonstration of the adequacy of the extended model to impIement lntelligent Network (lN) services, confirming the tendency of the unification of TMN and lN; Proposition of the application of Actor Theory in the impIementation of the proposed model, by extending the basic theory to include: priority event queues, the Aggregates concept (for Location Transparency) and a mechanism of Access Transparency, using ASN. language; and the construction of a supporting kernel for the impIementation of Actor Aggregates, using control threads facilities, the lSODE package and the C++ programming language / Doutorado / Telecomunicações e Telemática / Doutor em Engenharia Elétrica

Orientador: Andre L. Morelato França / Tese (doutorado) - Universidade Estadual de Campinas, Faculdade de Engenharia Eletrica e de Computação / Made available in DSpace on 2018-07-22T21:03:59Z (GMT). No. of bitstreams: 1 ManaceroJunior_Aleardo_D.pdf: 9426763 bytes, checksum: ebcfb5b39f21c096cc81e04234c4c74a (MD5) Previous issue date: 1997 / Resumo: O desenvolvimento de programas para ambientes de programação paralela exige do projetista uma atenção especial quanto ao desempenho obtido pelo conjunto programa-máquina. Os custos elevados de processamento fazem com que seja necessário obter o melhor desempenho possível para reduzir custos e tempos de processamento. O problema passa a ser como definir medidas de desempenho e como realizar as medições para verificar se o sistema é eficiente ou não. Existem diversas ferramentas de análise ou predição de desempenho, que procuram fornecer ao usuário dados sobre o programa, Para auxiliar o projetista a localizar pontos críticos do mesmo e fazer acertos para melhorar o desempenho do sistema. Infelizmente a maioria dessas ferramentas trabalha com grandes aproximações no modelo do ambiente paralelo, fazendo com que os resultados obtidos não sejam totalmente precisos. Além disso, quando essas ferramentas fazem uso de medidas experimentais para a realização da análise, elas acabam introduzindo erros experimentais pela necessidade de inserir código adicional ao programa analisado. Neste trabalho é apresentada uma nova metodologia para realizar medidas de desempenho sem a necessidade de código adicional ao programa e, além disso, sem a necessidade de usar a máquina alvo do programa durante todo o processo. A metodologia faz a reescrita do código executável para um grafo de execução... Observação: O resumo, na íntegra, poderá ser visualizado no texto completo da tese digital / Abstract: The process of writing a new code for a parallel programming environment demands from its designer a lot of attention on the performance achieved by the pair program-machine. The high processing costs justify the efforts to reduce processing time and costs, which leads to the problem of defining performance metrics and approaches to measure the system performance. Several performance analysis and prediction tools are available to help designers in such a task. With those tools the designer can locate critical points in the code and look for solutions to improve the program's performance. Unfortunately, most of those tools make so many approximations in the parallel environment model, that make themselves somewhat inaccurate. Moreover method of measurement usually adopted get performance data through an instrumented program's run. This approach affects the measures since additional code is inserted into the program under analysis. This work introduces a new method to make such measurements without including additional code nor requiring runs on the target parallel machine. The proposed approach is to rewrite the executable code into an execution graph, which is a directed graph that keeps the information about the processing time of each machine instruction included in the code under analysis... Note: The complete abstract is available with the full electronic digital thesis or dissertations / Doutorado / Doutor em Engenharia Elétrica