Master of Engineering (Research) / This thesis presents a new approach to ensuring fair service for highly concurrent requests. Our design uses the advantages of staged event-driven architecture (SEDA) to support high-concurrent loadings and makes use of control theory to manage the system performance. In order to guarantee the quality of service is fairly made to each request, based on SEDA, the control system for fairness is developed as a combination of a global control framework and a set of local self-tune stags. The global control framework is used to control the performance of the whole staged network at the top-level, aimed at coordinating the performance of the stages in the network. On the other hand, each self-tune stage under the control framework is built on the thread pool model, and will use automatic control theory to adjust its performance locally in order to meet the overall target performance. The automatic control system in each stage consists of an automatic modeling mechanism and a feedback module, which optimizes the controller parameters in the system automatically and guarantees the quality of performance (service rate here) for the stage at runtime. Based on mathematical proof and simulation results, our designs are implemented in a SEDA-based web server running in a dynamic loading environment. Results demonstrate that the performance of the new system in the real world is almost the same as the theoretical results. It demonstrates that the design is able to adaptively ensure the quality of service to the high-concurrent requests fairly. Compared to the original SEDA design, our design is an effective and handy approach to significantly enhancing the performance of SEDA in a variety of aspects, including fairer service, faster convergent speed, better robustness, higher accuracy and ease of deployment in various practical applications.

Thesis (M.Sc.). / Written for the School of Computer Science. Title from title page of PDF (viewed 2008/12/05). Includes bibliographical references.

Thesis (Ph. D.)--University of Washington, 1998. / Vita. Includes bibliographical references (p. [144]-155).

This thesis makes a comparison between the performance of Go and Java using parallelizedimplementations of the Classic Matrix Multiplication Algorithm (CMMA). The comparisonattempts to only use features for parallelization, goroutines for Go and threads for Java,while keeping other parts of the code as generic and comparable as possible to accuratelymeasure the performance during parallelization.In this report we ask the question of how programming languages compare in terms of multi-threaded performance? In high-performance systems such as those designed for mathemati-cal calculations or servers meant to handle requests from millions of users, multithreadingand by extension performance are vital. We would like to find out if and how much of a dif-ference the choice of programming language could benefit these systems in terms of parallel-ism and multithreading.Another motivation is to analyze techniques and programming languages that have emergedthat hide the complexity of handling multithreading and concurrency from the user, lettingthe user specify keywords or commands from which the language takes over and creates andmanages the thread scheduling on its own. The Go language is one such example. Is this newtechnology an improvement over developers coding threads themselves or is the technologynot quite there yet?To these ends experiments were done with multithreaded matrix multiplication and was im-plemented using goroutines for Go and threads for Java and was performed with sets of4096x4096 matrices. Background programs were limited and each set of calculations wasthen run multiple times to get average values for each calculation which were then finallycompared to one another.Results from the study showed that Go had ~32-35% better performance than Java between 1and 4 threads, with the difference diminishing to ~2-5% at 8 to 16 threads. The differencehowever was believed to be mostly unrelated to parallelization as both languages maintainednear identical performance scaling as the number of threads increased until the scaling flat-lined for both languages at 8 threads and up. Java did continue to gain a slight increase goingfrom 4 to 8 threads, but this was believed to be due to inefficient resource utilization onJava’s part or due to Java having better utilization of hyper-threading than Go.In conclusion, Go was found to be considerably faster than Java when going from the mainthread and up to 4 threads. At 8 threads and onward Java and Go performed roughly equal.For performance difference between the number of threads in the languages themselves nonoticeable performance increase or decrease was found when creating 1 thread versus run-ning the matrix multiplication directly on the main thread for either of the two languages.Coding multithreading in Go was found to be easier than in Java while providing greater toequal performance. Go just requires the ‘go’ keyword while Java requires thread creation andmanagement. This would put Go in favor for those trying to avoid the complexity of multi-threading while also seeking its benefits.

Made available in DSpace on 2014-06-12T16:01:28Z (GMT). No. of bitstreams: 2 arquivo9411_1.pdf: 1518901 bytes, checksum: d645deca05140af7b59c0d3726ee9757 (MD5) license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5) Previous issue date: 2011 / Com o advento de processadores multicore, a programação concorrente ganhou importância e tem se tornado um dos grandes desafios da área de engenharia de software. O paradigma de programação concorrente, implementado por linguagens de programação como Java, C, e C++, oferece um nível de expressividade muito baixo, dificultando a sua utilização. Aliado a isso, o uso de bibliotecas que implementam abstração de concorrência, requer um esforço de aprendizado adicional, como também produz programas cuja lógica da regra de negócio está entrelaçada com chamadas para a biblioteca que implementa concorrência de forma mais abstrata. O presente trabalho propõe separar o código concorrente daquele usado no desenvolvimento de código sequencial Java. Todo comportamento concorrente é extraído do código e torna-se anotações de classe. Tais anotações seguem a sintaxe da linguagem CSP, uma linguagem formal que foi criada para descrever sistemas concorrentes e distribuídos. Para prover esta separação, este trabalho sugere um compilador, chamado AJCSP, o qual reconhece as anotações nas classes Java, gerando código concorrente utilizando a biblioteca JCSP. A programação orientada a aspectos foi explorada para instrumentar o programa sequencial Java com construções concorrentes contidas no código gerado. Para avaliar o framework proposto, foram utilizadas métricas de separação de preocupações (SoC), acoplamento, bem como tamanho em cinco sistemas distintos implementados nas diferentes abordagens de concorrência (java thread, JCSP e AJCSP). A avaliação obtida demonstrou que, quando utilizado AJCSP, a quantidade de linhas de código do sistema diminui, assim como a dependência com a biblioteca de concorrência

Tato diplomová práce se zabývá otázkami výroby závitů tvářecími a řezacímí závitníky. Její první část popisuje druhy závitníků, které se používají ve strojírenství. Pak se práce zaměřuje na otázky základních principů řezání závitů a tváření materiálu při obrábění. Dále se zaměřuje na porovnání řezných momentů a dalších veličin při aplikaci tvářecích závitníků v procesu obrábění. Výsledkem experimentu bylo zjíštění průběhů řezných momentů v závislosti na čase, který byly statisticky zpracovány a vyhodnoceny.

The World Wide Web (WWW) has become the largest source of Internet traffic, but it was not designed for wireless networks. Documents with large inline images take a long time to fetch over low-bandwidth wireless networks. Radio signal dropouts cause file transfers to abort; users have to restart file transfers from the beginning. Dropouts also prevent access to documents that have not yet been visited by the user. All of these problems create user frustration and limit the utility of the WWW and wireless networks. In this work, a new Wireless World Wide Web (WWWW) proxy server and protocol were developed that address these problems. A client based on NCSA Mosaic connects to the proxy server using the new protocol, Multiple Hypertext Stream Protocol (MHSP). The proxy prefetches documents to the client, including inline images. The proxy also reduces the resolution of large bitmaps to improve performance over slow links. MHSP provides the ability to resume file transfers when the link has been broken then reestablished. The WWWW system was tested and evaluated by running script-controlled clients on different emulated network environments. This new system decreased document load time an average of 32 to 37 percent, depending on network configuration. / Master of Science

This thesis considers the problem of recovering from failures of distributable threads with assured timeliness. When a node hosting a portion of a distributable thread fails, it causes orphans—i.e., thread segments that are disconnected from the thread's root. A termination model is considered for recovering from such failures. In this model the orphans must be detected and cleaned up, and failure-exception notification must be delivered to the farthest, contiguous surviving thread segment for resuming thread execution. Two real-time scheduling algorithms (AUA and HUA) and three distributable thread integrity protocols (TPR, D-TPR and W-TPR) are presented. We show that AUA combined with any of the protocols presented bounds the orphan cleanup and recovery time, thereby bounding thread starvation durations and maximizing the total thread accrued timeliness utility. The algorithms and the protocols are implemented in a real-time middleware that supports distributable threads. The experimental studies with the implementation validate the algorithm/protocols' time-bounded recovery property and confirm their effectiveness. / Master of Science

Les supercalculateurs utilisés dans le HPC sont constitués de plusieurs machines inter-connectées. Généralement, elles sont programmées à l'aide de MPI qui spécifie une interface de programmation échanger des messages entre les machines. Les opérations MPI non-bloquantes ont été proposées pour recouvrir les communications par du calcul afin d'en amortir le coût. Initialement, ces opérations étaient uniquement disponibles pour les opérations entre 2 processus MPI : les communications point-à-point. L'extension des communications non-bloquantes aux opérations impliquant plus de 2 processus MPI, les opérations collectives, est apparue dans la version 3.0 de la norme MPI en 2012. Cela a ouvert la possibilité de recouvrir les communications collectives non-bloquantes par du calcul. Cependant, ces opérations consomment plus de temps CPU que les opérations point-à-point. Nous proposons d'aborder ce problème sous plusieurs angles. D'une part, nous nous concentrons sur le placement des threads de progression générés par les collectives MPI non-bloquantes. Pour cela, nous proposons deux algorithmes de placement des threads de progression pour toutes les collectives MPI non-bloquantes. Le premier est de regrouper les threads de progression sur des cœurs libres. Le second est de placer les threads de progression sur les hyper-threads. Pour être plus efficace, nous nous concentrons ensuite sur l'optimisation de deux types d'algorithme utilisés pour les opérations collectives : les algorithmes en arbre et les algorithmes en chaîne. D'autre part, nous avons aussi étudié l'ordonnancement des threads de progression afin d'éviter l'exécution de threads inutiles à la progression de l'algorithme. Pour cela, nous proposons d'abord d'utiliser un mécanisme permettant de suspendre l'ordonnancement de ces threads, puis de forcer l'ordonnancement optimal des threads de progression de façon statique à l'aide de sémaphores. Enfin, une politique d'ordonnancement avec des priorités a été mise en place comme preuve de concept. / Supercomputers used in HPC are composed of severals inter-connected machines. Usually, they are programmed using MPI which specify an API for messages exchanges between machines. To amortize the cost of MPI collective operations, non-blocking collectives have been proposed so as to allow communications to be overlapped with computation. Initially, these operations were only available for communication between 2 MPI processes : point-to-point communications. Non-blocking communications were expanded to collective communications in 2012 with MPI 3.0. This opens up the possibility to overlap non-blocking collective communications with computation. However, these operations are more CPU-hungry than point-to-point communications. We propose to approach this problem from several angles. On the one hand, we focus on the placement of progress threads generated by the MPI non-blocking collectives. We propose two progress threads placements algorithms for all non-blocking collectives. We either bind them on free cores, or we bind them on the hyper-threads. Then, we focus on optimizing two types of algorithms used by collective operations: tree-based algorithms and chain-based algorithms. On the other hand, we also study the scheduling of progress threads to avoid their execution when it is unecessary to the advancement of the collective algorithm. For that, we propose first to use a mechanism to suspend the scheduling of these threads, and then we force their optimal scheduling statically by using semaphores. Finally, we introduce a proof of concept scheduling policy with priorities.

Recommendation techniques are developed to discover user¡¦s real information need among large amounts of information. Recommendation systems help users filter out information and attempt to present those similar items according to user¡¦s tastes. In our work, we focus on discussion threads recommendation in the tourism domain. We assume that when users have traveling information need, they will try to search related information on the websites. In addition to browsing others suggestions and opinions, users are allowed to express their need as a question. Hence, we focus on recommending users previous discussion threads that may provide good answers to the users¡¦ questions by considering the question input as well as their browsing records. We propose a model, which consists of four perspectives: goal similarity, content similarity, freshness and quality. To validate and the effectiveness of our model on recommendation performance, we collected 14348 threads from TripAdvisor.com, the largest travel website, and recruited ten volunteers, who have interests in the tourism, to verify our approach. The four perspectives are utilized by two methods. The first is Question-based method, which makes use of content similarity, freshness and quality and the second is Session-based method, which involves goal similarity. We also integrate the two methods into a hybrid method. The experiment results show that the hybrid method generally has better performance than the other two methods.