Spelling suggestions: "subject:"[een] MULTITHREADING"" "subject:"[enn] MULTITHREADING""
11 |
Design and Evaluation of the Hamal Parallel ComputerGrossman, J.P. 05 December 2002 (has links)
Parallel shared-memory machines with hundreds or thousands of processor-memory nodes have been built; in the future we will see machines with millions or even billions of nodes. Associated with such large systems is a new set of design challenges. Many problems must be addressed by an architecture in order for it to be successful; of these, we focus on three in particular. First, a scalable memory system is required. Second, the network messaging protocol must be fault-tolerant. Third, the overheads of thread creation, thread management and synchronization must be extremely low. This thesis presents the complete system design for Hamal, a shared-memory architecture which addresses these concerns and is directly scalable to one million nodes. Virtual memory and distributed objects are implemented in a manner that requires neither inter-node synchronization nor the storage of globally coherent translations at each node. We develop a lightweight fault-tolerant messaging protocol that guarantees message delivery and idempotence across a discarding network. A number of hardware mechanisms provide efficient support for massive multithreading and fine-grained synchronization. Experiments are conducted in simulation, using a trace-driven network simulator to investigate the messaging protocol and a cycle-accurate simulator to evaluate the Hamal architecture. We determine implementation parameters for the messaging protocol which optimize performance. A discarding network is easier to design and can be clocked at a higher rate, and we find that with this protocol its performance can approach that of a non-discarding network. Our simulations of Hamal demonstrate the effectiveness of its thread management and synchronization primitives. In particular, we find register-based synchronization to be an extremely efficient mechanism which can be used to implement a software barrier with a latency of only 523 cycles on a 512 node machine.
|
12 |
Conjoint component designs for high performance dependable single chip multithreading systems /Wang, Hui. January 2007 (has links)
Thesis (Ph.D.)--University of Texas at Dallas, 2007. / Includes vita. Includes bibliographical references (leaves 94-103)
|
13 |
Improving throughput of simultaneous multithreaded (SMT) processors using shareable resource signatures and hardware thread prioritiesMeswani, Mitesh R., January 2009 (has links)
Thesis (Ph. D.)--University of Texas at El Paso, 2009. / Title from title screen. Vita. CD-ROM. Includes bibliographical references. Also available online.
|
14 |
Multithreaded programming and execution models for reconfigurable hardwareLübbers, Enno January 2010 (has links)
Zugl.: Paderborn, Univ., Diss., 2010
|
15 |
End of Insertion Detection in Colonoscopy VideosMalik, Avnish Rajbal 08 1900 (has links)
Colorectal cancer is the second leading cause of cancer-related deaths behind lung cancer in the United States. Colonoscopy is the preferred screening method for detection of diseases like Colorectal Cancer. In the year 2006, American Society for Gastrointestinal Endoscopy (ASGE) and American College of Gastroenterology (ACG) issued guidelines for quality colonoscopy. The guidelines suggest that on average the withdrawal phase during a screening colonoscopy should last a minimum of 6 minutes. My aim is to classify the colonoscopy video into insertion and withdrawal phase. The problem is that currently existing shot detection techniques cannot be applied because colonoscopy is a single camera shot from start to end. An algorithm to detect phase boundary has already been developed by the MIGLAB team. Existing method has acceptable levels of accuracy but the main issue is dependency on MPEG (Moving Pictures Expert Group) 1/2. I implemented exhaustive search for motion estimation to reduce the execution time and improve the accuracy. I took advantages of the C/C++ programming languages with multithreading which helped us get even better performances in terms of execution time. I propose a method for improving the current method of colonoscopy video analysis and also an extension for the same to make it usable for real time videos. The real time version we implemented is capable of handling streams coming directly from the camera in the form of uncompressed bitmap frames. Existing implementation could not be applied to real time scenario because of its dependency on MPEG 1/2. Future direction of this research includes improved motion search and GPU parallel computing techniques.
|
16 |
Reingeniería back-end SoyMomoRamírez Gutiérrez, Manuel Alejandro January 2019 (has links)
Memoria para optar al título de Ingeniero Civil en Computación / SoyMomo es un reloj-celular-GPS para niños que permite a los padres -entre otras funciones- saber dónde se encuentran y poder hacer llamadas desde y hacia el reloj, a través de aplicaciones móviles. Estos relojes tienen un módulo GSM (2G) y se comunican a un servidor a través de sockets TCP.
El sistema se compone de un servidor desarrollado en Node.js y un sistema de Backend as a Service que almacena la base de datos. Debido al sostenido aumento de usuarios de éste, el servidor ha alcanzado el límite de capacidad, utilizando todos los recursos que estaba diseñado para usar. Este límite sin embargo, no es el límite del sistema, por lo tanto existían oportunidades de mejora.
Además, también se alcanzaba el límite de consultas por segundo en la base de datos, lo que provocaba la pérdida de información debido a que el servidor rechazaba las consultas sobre ese límite.
Se realizó una reingeniería del servidor, identificando los puntos más críticos de falla: diseño, rendimiento y optimización de consultas; y se reescribió el \textit{software} utilizando el lenguaje Go, aplicando conceptos de paralelismo y concurrencia, con el fin de mejorar el rendimiento y crear un sistema escalable.
Para esto, se reestructuró el programa en secciones pequeñas de código capaces de ejecutarse de forma concurrente, con el fin de utilizar las bondades del \textit{scheduler} lenguaje, que es capaz de repartir el trabajo entre todos los \textit{cores} disponibles del procesador.
Además, se creó una sección central que se encarga de agrupar consultas a la base de datos y enviarlas en lotes, permitiendo atender a la misma cantidad de clientes con menos recursos.
Finalmente se pudo concluir que las mejoras planificadas cumplen con lo propuesto, realizando una utilización óptima de los recursos del sistema, al lograr atender un 19\% más de clientes con lel mismo número de consultas; eliminando la pérdida de información y rebajando el uso de CPU a menos del 20\%.
|
17 |
[en] AN ALTERNATIVE MODEL FOR CONCURRENT PROGRAMMING IN LUA / [pt] UM MODELO ALTERNATIVO PARA PROGRAMAÇÃO CONCORRENTE EM LUAALEXANDRE RUPERT ARPINI SKYRME 23 July 2008 (has links)
[pt] A popularização dos processadores multinúcleo e de
tecnologias como o hyper-threading evidencia uma mudança de
foco na evolução dos processadores. Essa mudança fomenta o
interesse por programação concorrente e a exploração de
paralelismo para obtenção de melhor desempenho. Entretanto,
os modelos atuais para programação concorrente são alvo de
críticas recorrentes, o que estimula a elaboração de
propostas alternativas. Este trabalho apresenta uma análise
crítica do multithreading preemptivo com compartilhamento de
memória, um modelo amplamente utilizado para programação
concorrente, e faz um breve apanhado de trabalhos que
abordam alternativas para programação concorrente. Em
seguida, propõe um modelo para programação concorrente
estruturado com a linguagem de programação Lua e descreve as
suas principais características e vantagens. Finalmente,
apresenta os resultados da avaliação de diversos aspectos de
uma biblioteca desenvolvida para implementar o modelo proposto. / [en] The popularization of multi-core processors and of
technologies such as hyper-threading indicates a different
approach to the evolution of processors. This new approach
brings about an increased interest in concurrent
programming and the exploration of parallelism in order to
achieve better performance. However, concurrent programming
models now in use are subject to recurring criticism, which
stimulates the development of alternative
proposals. This work presents a critical analysis of
preemptive multithreading with shared memory, which is a
widely used model for concurrent programming,
and brie y summarizes some studies that deal with
alternatives for concurrent programming. It then, proposes a
model for concurrent programming structured with the Lua
programming language and describes its main characteristics
and advantages. Finally, it presents the results of
an evaluation of several aspects of a library developed to
implement the proposed model.
|
18 |
[en] SAFE RECORD SHARING IN DYNAMIC PROGRAMMING LANGUAGES / [pt] COMPARTILHAMENTO SEGURO DE REGISTROS EM LINGUAGES DE PROGRAMAÇÃO DINÂMICASALEXANDRE RUPERT ARPINI SKYRME 29 February 2016 (has links)
[pt] Linguagens de programação dinâmicas estão cada vez mais populares e já
foram utilizadas para desenvolver uma ampla gama de aplicações. Enquanto
isso, processadores multi-núcleo se tornaram padrão, mesmo em computadores
pessoais e dispositivos móveis. Dessa forma, os programadores precisam
recorrer ao paralelismo para aprimorar o desempenho de seus programas.
Entretanto, a programação concorrente permanece difícil. Adicionalmente,
a despeito de avanços em linguagens estáticas, avaliamos que linguagens
dinâmicas ainda carecem de suporte adequado à concorrência. Nesta
tese argumentamos que o principal problema da programação concorrente é
a imprevisibilidade - comportamentos inesperados de programas, tais como
retornar valores descabidos. Observamos que a imprevisibilidade é mais
provável quando memória compartilhada é utilizada. Consequentemente,
propomos um modelo de comunicação para concorrência que visa disciplinar
o compartilhamento de memória em linguagens dinâmicas. O modelo
é baseado nos padrões emergentes de concorrência de não compartilhar dados
por padrão, imutabilidade de dados e tipos e efeitos (que transformamos
em capacidades). Ele demanda a utilização de objetos compartilháveis para
compartilhar dados e utiliza troca de mensagens para comunicação entre
fluxos de execução. Objetos compartilháveis podem ser compartilhados apenas para
leitura ou para leitura e escrita, o que permite acesso individual de
escrita e acessos paralelos de leitura. Implementamos um protótipo em Lua
para experimentar com o modelo na prática, bem como para conduzir uma
avaliação geral de desempenho. A avaliação demonstra que há benefícios na
utilização de memória compartilhada, mas ao mesmo tempo revela que os
controles utilizados para assegurar a disciplina ocasionam um impacto de
desempenho. / [en] Dynamic programming languages have become increasingly popular and
have been used to implement a range of applications. Meanwhile, multicore
processors have become the norm, even for desktop computers and
mobile devices. Therefore, programmers must turn to parallelism as a
means to improve performance. However, concurrent programming remains
difficult. Besides, despite improvements in static languages, we find dynamic
languages are still lacking in concurrency support. In this thesis, we argue
that the main problem with concurrent programming is unpredictability -
unexpected program behaviors, such as returning out-of-thin-air values. We
observe that unpredictability is most likely to happen when shared memory
is used. Consequently, we propose a concurrency communication model to
discipline shared memory in dynamic languages. The model is based on
the emerging concurrency patterns of not sharing data by default, data
immutability, and types and effects (which we turn into capabilities). It
mandates the use of shareable objects to share data. Besides, it establishes
that the only means to share a shareable object is to use message passing.
Shareable objects can be shared as read-write or read-only, which allows
both individual read-write access and parallel read-only access to data. We
implemented a prototype in Lua, called luashare, to experiment with the
model in practice, as well as to carry out a general performance evaluation.
The evaluation showed us that safe data sharing makes it easier to allow
for communication among threads. Besides, there are situations where
copying data around is simply not an option. However, enforcing control
over shareable objects has a performance cost, in particular when working
with nested objects.
|
19 |
ANALYSE STATIQUE DE LOGICIELS MULTITÂCHES PAR INTERPRÉTATION ABSTRAITEFerrara, Pietro 22 September 2009 (has links) (PDF)
Le but de cette thèse est de présenter une analyse statique générique pour des programmes multitâche écrits en Java.<br />Les programmes multitâche exécutent plusieurs tâches en parallèle. Ces tâches communiquent implicitement par le biais de la mémoire partagée et elles se synchonisent sur des moniteurs (les primitives wait-notify, etc..). Il y a quelques années, les architectures avec double processeurs ont commencé à être disponibles sur le marché à petit prix. Aujourd'hui, presque tous les ordinateurs ont au moins deux noyaux, la tendance actuelle du marché étant de mettre de plus en plus de processeurs par puce. Cette révolution amène également de nouveaux défis en matière de programmation, car elle demande aux développeurs d'implanter des programmes multitâche. Le multitâche est supporté en natif par la plupart des langages de programmation courants, comme Java et C#.<br />Le but de l'analyse statique est de calculer des informations sur le comportement d'un programme, de manière conservative et automatique. Une application de l'analyse statique est le développement d'outils qui aident au débogage des programmes. Plusieurs méthodes d'analyse statique ont été proposées. Nous suivrons le cadre de l'interprétation abstraite, une théorie mathématique permettant de définir des approximations correctes de sémantiques de programmes. Cette méthode a déjà été utilisée pour un large spectre de langages de programmation.<br />L'idée fondamentale des analyseurs statiques génériques est de développer un outils qui puissent être interfacé avec différents domaines numériques et différentes propriétés. Pendant ces dernières années, beaucoup de travaux se sont attaqués à cet enjeu, et ils ont été appliqué avec succès pour déboguer des logiciels industriels. La force de ces analyseurs réside dans le fait qu'une grande partie de l'analyse peut être réutilisée pour vérifier plusieurs propriétés. L'utilisation de différents domaines numériques permet le développement d'analyses plus rapides mais moins précises, ou plus lentes mais plus précises.<br /><br />Dans cette thèse, nous présentons la conception d'un analyseur générique pour des programmes multitâche. Avant tout, nous définissons le modèle mémoire, appelé happens-before memory model. Puis, nous approximons ce modéle mémoire en une semantique calculable. Les modéles mémoire définissent les comportements autorisés pendant l'exé-cution d'un programme multitâche. Commençant par la définition (informelle) de ce modèle mémoire particulier, nous définissons une sémantique qui construit toutes les exécutions finies selon ce modèle mémoire. Une exécution d'un programme multitâche est décrite par une function qui associe les tâches à des séquences (ou traces) d'états. Nous montrons comment concevoir une sémantique abstraite calculable, et nous montrons formellement la correction des résultat de cette analyse.<br />Ensuite, nous définissons et approximons une nouvelle propriété qui porte sur les comportements non-déterministes causés par le multitâche, c'est à dire aux entrelacements arbitraires pendant l'exécution de differentes instructions de lecture. Avant tout, le non déterminisme d'un programme multitâche se définit par une différence entre plusieurs exécutions. Si deux exécutions engendrent des comportements différents dus au valeurs qui sont lues ou écrites en mémoire partagée, alors le programme est non déterministe. Nous approximons cette propriété en deux étapes: dans un premier temps, nous regroupons, pour chaque tâche, la valeur (abstraite) qui peut être écrite dans la mémoire partagée à un point de programme donné. Dans un deuxième temps, nous résumons toutes les valeurs pouvant être écrites en parallèle, tout en nous rapellant l'ensemble des tâches qui pourraient les avoir écrites. à un premier niveau d'approximation, nous introduisons un nouveau concept de déterminisme faible. Nous proposons par ailleurs d'autres manière affaiblir la propriété de déterminisme, par exemple par projection des traces et des états, puis nous définissons une hierarchie globale de ces affaiblissements. Nous étudions aussi comment la présence de conflit sur les accès des données peut affecter le déterminisme du programme.<br />Nous appliquons ce cadre de travail théorique à Java. En particulier, nous définissons une sémantique du language objet de Java, selon sa spécification. Ensuite, nous approximons cette sémantique afin de garder uniquement l'information qui est nécessaire pour l'analyse des programmes multitâche. Le cœur de cette abstraction est une analyse d'alias qui approxime les références afin d'identifier les tâches, de vérifier les accès en mémoire partagée, et de détecter quand deux tâches ont un moniteur commun afin d'en déduire quelles parties du code ne peuvent pas être éxécutées en parallèle.<br />L'analyseur générique qui est décrit ci-dessus a été entierement implanté, dans un outils appelé Checkmate. Checkmate est ainsi le premier analyseur générique pour des programmes multitâche écrits en Java. Des résultats expérimentaux sont donnés et analysés en détails. En particulier, nous étudions la précision de l'analyse lorsqu'elle est appliquée à des schémas courants de la programmation concurrente, ainsi qu'à d'autres exemples. Nous observons également les performances de l'analyse lorsqu'elle est appliquée à une application incrémentale, ainsi qu'à des exemples de références bien connus.<br />Une autre contribution de cette thèse est l'extension d'un analyseur générique existant qui s'appelle Clousot et qui permet de vérifier le non débordement des mémoires tampons. Il s'avère que cette analyse passe à l'échelle des programmes industriels et qu'elle est précise. En résumé, nous présentons une application d'un analyseur statique générique industriel existant pour détecter et prouver une propriété présentant un intérêt pratique, ce qui montre la puissance de cette approche dans le développement d'outils qui soient utiles pour les développeurs.
|
20 |
A Framework for Testing Concurrent ProgramsJanuary 2011 (has links)
This study proposes a new framework that can effectively apply unit testing to concurrent programs, which are difficult to develop and debug. Test-driven development, a practice enabling developers to detect bugs early by incorporating unit testing into the development process, has become wide-spread, but it has only been effective for programs with a single thread of control. The order of operations in different threads is essentially non-deterministic, making it more complicated to reason about program properties in concurrent programs than in single-threaded programs. Because hardware, operating systems, and compiler optimizations influence the order in which operations in different threads are executed, debugging is problematic since a problem often cannot be reproduced on other machines. Multi-core processors, which have replaced older single-core designs, have exacerbated these problems because they demand the use of concurrency if programs are to benefit from new processors. The existing tools for unit testing programs are either flawed or too costly. JUnit , for instance, assumes that programs are single-threaded and therefore does not work for concurrent programs; ConTest and rstest predate the revised Java memory model and make incorrect assumptions about the operations that affect synchronization. Approaches such as model checking or comprehensive schedule-based execution are too costly to be used frequently. All of these problems prevent software developers from adopting the current tools on a large scale. The proposed framework (i) improves JUnit to recognize errors in all threads, a necessary development without which all other improvements are futile, (ii) places some restrictions on the programs to facilitate automatic testing, (iii) provides tools that reduce programmer mistakes, and (iv) re-runs the unit tests with randomized schedules to simulate the execution under different conditions and on different machines, increasing the probability that errors are detected. The improvements and restrictions, shown not to seriously impede programmers, reliably detect problems that the original JUnit missed. The execution with randomized schedules reveals problems that rarely occur under normal conditions. With an effective testing tool for concurrent programs, developers can test programs more reliably and decrease the number of errors in spite of the proliferation of concurrency demanded by modern processors.
|
Page generated in 0.052 seconds