The aim of this work is to investigate whether threaded Android-applications written in C or C++ are more time-efficient than threaded Android-applications written in Java. The first part of the work was to perform a literature analysis in order to find out which types of algorithms were used in previous studies comparing the performance between non-threaded Android-applications written in Java and C/C++. Another literature analysis was performed where the outcome was to find suitable threaded versions of algorithms that could be used to compare the difference in time-consumption between algorithms implemented in Java and C/C++. Results have shown that for simple arithmetic operations and sorting functions, it is still possible to gain performance in terms of time-efficiency by implementing applications in C/C++. However, there are clear indications that these gains are smaller than they are in the non-threaded case. In algorithms dealing with string operations, the Java-version was significantly more time-efficient than the C++-version

This thesis is an analysis of frameworks which support multithreading application devel-opment on platform Java. In particular this thesis analyses the overview of libraries which supports multithreading development in this language. Provided features are shown and described by the code examples. The thesis describes the principles of concurrent pro-gramming. Although multithreaded applications undoubtedly have many advantages, one of the goals of the thesis is to highlight the possible risks associated with their use. By the analysis of Java platform, I used method of description, analysis, synthesis and comparison. This thesis is composed of theoretical part, which defines the basic concepts and principles of concurrent applications. Theoretical parts also contain recherché of works, which deal with the topic of concurrent programming. In the analytical part are described and evaluated changes at various versions of Java language. Benefit of this work is clear documentation and evaluation of Java language concurrent utilities, from the oldest version of Java 1 to latest Java 8. So this work can help those, who need to learn how to develop concurrent applications in Java.

Context - Software applications on the web are more commonly used nowadays than before. As a result of this, the performance needed to run the applications is increasing. One method to increase performance is writing multi-threaded code using Web Workers in JavaScript. Objectives - We will investigate how using Web Workers can increase responsiveness, raw computational power and decrease load time. Additionally, we will conduct a survey that targets software developers to find out their opinions about performance in web applications, multi-threading and more specifically Web Workers. Realization (Method) - We created three experiments that concentrate on the areas mentioned above. The experiments are hosted on a web server inside an isolated Docker container to eliminate external factors as much as possible. To complement the experiments we sent out a survey to collect information of developers' opinions about Web Workers. The criteria for the selection of developers were some JavaScript experience. The survey contained questions about their opinions on switching to a multi-threaded workflow on the web. Do they experience performance issues in today's web applications? Could Web Workers be useful in their projects? Results - Responsiveness shifted from freezing the website to perfect responsiveness when using Web Workers. Raw computational power increased at best 67% when using eight workers with tasks that took between 100 milliseconds and 15 seconds. Over 15 seconds, sixteen workers improved the computational power further with around 3% - 9% compared to eight workers. At best the completion time decreased with 74% in Firefox and 72% in Chrome. Using Web Workers to help with load time gave a big improvement but is somewhat restricted to specific use cases. Conclusions - Using Web Workers to increase responsiveness made an immense difference when moving tasks that is affecting the users responsiveness to background threads. Completion time for big computational tasks was quicker in use cases where you can split the workload to separate portions and use multiple threads in parallel to complete the tasks. Load time can be improved with Web Workers by completing some tasks after the page is done loading, instead of waiting for all tasks to complete and then load the page. The survey indicated that many have performance in mind and would consider writing code in a multi-threaded way. The knowledge about multi-threading and Web Workers was low. Although, most of the participants believe that Web Workers would be useful in their current and future projects, and are worth the effort to implement.

Due to the ever increasing complexity of safety-critical applications, handwritten code is being replaced by automatically generated code derived from a high level specification. Code generation from high level specification requires a model of computation with an underlying formalism and correctness-preserving refinement steps to generate the lower level application code. Such software synthesis techniques are said to be 'correct-by-construction'. Synchronous programming languages such as Esterel, LUSTRE, which are based on a synchronous model of computation are used for sequential code generation. They work on a synchrony assumption (zero time intraprocess computation and zero time inter process communication) at the specification level. Early versions of synchronous languages followed an execution pattern where an iteration of software was mapped to an interval between ticks of an external reference clock. Since this external reference tick was unrelated to variables (or signals) within the software, redundant operations such as reading of ports, computation of guards were performed for each tick. In this dissertation, we highlight some of these performance issues and missed optimization opportunities. Also we show how a multi-clock (or polychronous) formalism, where each variable has an independent rate of execution associated with it, can avoid these problems. An existing polychronous language named SIGNAL, creates a hierarchy of clocks based on the rate of execution of individual variables, to form a root clock which acts a reference tick. We seek to replace the clock analysis with a technique to form a unique order of events without a reference time line. For this purpose, we present a new polychronous formalism termed Multi-rate Instantaneous Channel connected Data Flow (MRICDF). Our new synthesis technique inspects the specification to identify a master trigger at a Boolean equation level to act as the reference tick. Furthermore, we attempt to make polychronous specification based software synthesis more accessible to practicing engineers, by constructing a software tool EmCodeSyn, with a visual environment for specification and a more intuitive analysis technique. Our Boolean approach to sequential synthesis of embedded software has multiple implementations, each of which utilizes existing academic software tools. Optimizations are proposed to minimize synthesis time by simplifying the input to these external tools. Weaknesses in causal loop analysis techniques applied by existing synthesis tools are highlighted and solutions for performing time efficient loop analysis are integrated into EmCodeSyn. We have also determined that a part of the non-synthesizable polychronous specifications can be used to generate correct multi-threaded code. Additionally, we investigate composition of polychronous modules and propose properties that are necessary to guarantee agreement on shared signals. / Ph. D.

Hlavním cílem této práce je navrhnout novu metodu rekonstrukce obrazu z dat fotoakustického snímkování. Fotoakustické snímkování je velmi populární neinvazivní metoda snímkování založená na detekování ultrazvukových vln vyvolaných laserovým paprskem. Proces snímkování generuje velké množství dat, a kvůli tomu je proces rekonstrukce obrazu velmi časově náročný. Táto práce demonstruje proces rekonstrukce obrazu pomocí zpětné projekce, algoritmu který je dostatečně jednoduchý na přizpůsobení moderním architekturám procesorů umožňující různé způsoby optimalizovaného výpočtu. Dvě různé variantu algoritmu byly navrženy: z pohledu pixelu a z pohledu senzoru, který detekuje ultrazvukové vlny. Obě varianty byly implementovány třemi různými způsoby: pomocí vektorového paralelismu, vláknového paralelismu a paralelismu na grafické karetě (GPU). Všechny 3 implementace obou variant algoritmu byly testovány a výsledky byly srovnány s výsledkem rekonstrukce algoritmu reverzního času, přesnějšího ale mnohokrát pomalejšího algoritmu. Výsledky ukázaly, že GPU paralelismus nabízí nejrychlejší výpočet, cca. 200 krát rychlejší než u algoritmu reverzního času, a proto se dá použit i v aplikacích pracující v reálném čase.

In contemporary IT industry, Multi-tasking solutions are highly regarded as optimal solutions, because hardware is equipped with multi-core CPUs.  With Multi-Core technology, CPUs run with lower frequencies while giving same or better performance as a whole system of processing. This thesis work takes advantage of multi-threading architecture in order to run different tasks under different cores such as SIP signaling and messaging to establish one or more SIP calls, capture voice, medical data, and packetize them to be streamed over internet to other SIP agents. VoIP is designed to stream voice over IP. There is inter-protocol communication and cooperation such as between the SIP, SDP, RTP, and RTCP protocols in order to establish a SIP connection and- afterwards- stream media over the internet. We use the Microsoft COM technology in order to better the C++ component design. It allows us to design and develop code once and run it anywhere on different platforms. Using VC++ helps us reduce software design time and development time. Moreover, we follow software design standards setup by software engineers’ society. VoIP technology uses protocols such as the SIP signaling protocol to locate the user agents that communicate with each other. Pjsip is a library that allows developers to extend their design with SIP capability. We use the PJSIP library in order to sign up our own developed VoIP module to a SIP server over the Internet and locate other user agents. We implement and use the already-designed iRTP protocol instead of the RTP to stream media over the Internet. Thus, we can improve RTP packet delays and improve Quality of Service (QoS). Since medical data is critical and must not be lost, the iRTP guarantees no loss of medical data. If we want to stream voice only, we would not need iRTP, because RTP is a good protocol for voice applications. Due to the increasing Internet traffic, we need to use a reliable protocol that can detect packet loss of medical data. iRTP resolves the issue and leverages QoS. This thesis work focuses on streaming medical data and medical voice-calls using VoIP, even over small bandwidths and in high traffic periods. The main contribution of this thesis is in the parallel design of iRTP and the implementation of this very design in order to be used with Multi-Core technology. We do so via multi-threading technology to speed up the streaming of medical data and medical voice-calls. According to our tests, measurements, and result analyses, the parallel design of iRTP and the multithreaded implementation on VC++ leverage performance to a level where the average decrease in delay is 71.1% when using iRTP for audio and medical data instead of the nowadays applied case of using an RTP stream for audio and multiple TCPs streams for medical data .

The history of mitigation programs to contain vector-borne diseases is a story of successes and failures. Due to the complex interplay among multiple factors that determine disease dynamics, the general principles for timely and specific intervention for incidence reduction or eradication of life-threatening diseases has yet to be determined. This research discusses computational methods developed to assist in the understanding of complex relationships affecting vector-borne disease dynamics. A computational framework to assist public health practitioners with exploring the dynamics of vector-borne diseases, such as malaria and dengue in homogenous and heterogeneous populations, has been conceived, designed, and implemented. The framework integrates a stochastic computational model of interactions to simulate horizontal disease transmission. The intent of the computational modeling has been the integration of stochasticity during simulation of the disease progression while reducing the number of necessary interactions to simulate a disease outbreak. While there are improvements in the computational time reducing the number of interactions needed for simulating disease dynamics, the realization of interactions can remain computationally expensive. Using multi-threading technology to improve performance upon the original computational model, multi-threading experimental results have been tested and reported. In addition, to the contact model, the modeling of biological processes specific to the corresponding pathogen-carrier vector to increase the specificity of the vector-borne disease has been integrated. Last, automation for requesting, retrieving, parsing, and storing specific weather data and geospatial information from federal agencies to study the differences between homogenous and heterogeneous populations has been implemented.

Cette étude consiste à résoudre de grands systèmes linéaires creux sur des calculateurs massivement parallèles. Ces systèmes linéaires, souvent rencontrés lors de la simulation numérique de problèmes de mécanique des structures par des codes de calcul par éléments finis, sont résolus avec des coûts très importants en temps de calcul et en espace mémoire. Dans cette thèse, nous mettons au point un parallélisme à deux niveaux et l'intégrons dans les méthodes de décomposition de domaine de type FETI. La démarche s'est organisée autour de trois chapitres principaux. Dans un premier temps, nous mettons en œuvre un solveur direct pour inverser des systèmes linéaires creux qui peuvent être symétriques ou non symétriques, réels ou complexes, à second membre simple ou multiple. La mise en œuvre, basée sur une technique de renumérotation de type dissection emboîtée, est complétée par un point utile dans beaucoup de méthodes de décomposition de domaine (construction d'un préconditionneur ou formulation de l'opérateur de FETI) : la détection de modes à énergie nulle des systèmes singuliers. Dans un deuxième temps, nous parallélisons le solveur direct à travers un modèle de parallélisme à mémoire partagée (multi-threading) pour tirer profit des nouveaux processeurs multi-coeurs. Dans un troisième temps, nous intégrons cette version multi-threads du solveur dans les méthodes FETI pour inverser les problèmes locaux en parallèle. Les résultats de cette étude mettent en évidence l'utilité des travaux effectués et l'intérêt d'utiliser comme solveur local dans les méthodes FETI un solveur direct parallèle robuste et efficace. Tout ceci peut donner accès à de nouvelles gammes de problèmes en calcul des structures. Il serait intéressant de revoir le parallélisme à gros grains entre sous-domaines dans les méthodes FETI. Cela pourrait consister à utiliser la version du solveur direct à second membre multiple pour améliorer plus la méthode itérative utilisée dans la résolution du problème d'interface.

This thesis represents an attempt to improve the state of the art in our ability tounderstand and check object protocols, with a particular emphasis on concurrent pro-grams. Object protocols are the patterns of use imposed on clients of APIs in object-oriented programs. We show through an empirical study of open-source object-oriented programs that object protocols are quite common. We then present “Sync-or-Swim,” a methodology and suite of accompanying tools for checking at compile-time that object protocols are used and implemented correctly. This methodology isbased upon the existing access permissions method of alias control, which is hereextended to be sound in the face of shared-memory concurrency. The analysis isformalized as a type system for an object-oriented calculus, and then proven to befree from false-negatives using a proof of type safety. The type system is extendedwith parametric polymorphism, or “generics,” in order to increase its ability to checkcommonly occurring patterns. An implementation of the approach, a static analysisfor programs written in the Java programming language, is presented. This imple-mentation was used to perform a series of case studies whose goal was to evaluatethe ease of use, expressiveness and ability to verify commonly occurring patterns.These case studies are presented. Next, an approach and an associated tool for in-ferring access permission annotations is presented. This inference tool can reducethe burden of using our protocol-checking approach by automatically inferring therequired typing annotations. This inference is built upon a system of probabilisticconstraints, which allows the easy encoding of heuristics. Finally, an optimization ofsoftware transactional memory runtimes is presented. This optimization is enabledby the typing annotations required to use the concurrent protocol checker and canremove some of the overhead typically associated with transactional memory sys-tems. As a result of the work presented in this thesis, it is possible to guarantee theabsence of certain API usage errors even in concurrent programs, and to do so witha low burden on programmers. By adhering to such an approach, programmers canproduce more reliable software.

Strongly inspired by an understanding of mammalian cortical structure and function, the Hierarchical Temporal Memory Cortical Learning Algorithm (HTM CLA) is a promising new approach to problems of recognition and inference in space and time. Only a subset of the theoretical framework of this algorithm has been studied, but it is already clear that there is a need for more information about the performance of HTM CLA with real data and the associated computational costs. For the work presented here, a complete implementation of Numenta's current algorithm was done in C++. In validating the implementation, first and higher order sequence learning was briefly examined, as was algorithm behavior with noisy data doing simple pattern recognition. A pattern recognition task was created using sequences of handwritten digits and performance analysis of the sequential implementation was performed. The analysis indicates that the resulting rapid increase in computing load may impact algorithm scalability, which may, in turn, be an obstacle to widespread adoption of the algorithm. Two critical hotspots in the sequential code were identified and a parallelized version was developed using OpenMP multi-threading. Scalability analysis of the parallel implementation was performed on a state of the art multi-core computing platform. Modest speedup was readily achieved with straightforward parallelization. Parallelization on multi-core systems is an attractive choice for moderate sized applications, but significantly larger ones are likely to remain infeasible without more specialized hardware acceleration accompanied by optimizations to the algorithm.