Testing concurrent programs remains a difficult task due to the non-deterministic nature of concurrent execution. Many approaches have been proposed to tackle the complexity of uncovering potential concurrency bugs. Static analysis tackles the problem by analyzing a concurrent program looking for situations/patterns that might lead to possible errors during execution. In general, static analysis cannot precisely locate all possible concurrent errors. Dynamic testing examines and controls a program during its execution also looking for situations/patterns that might lead to possible errors during execution. In general, dynamic testing needs to examine all possible execution paths to detect all errors, which is intractable. Motivated by these observation, a new testing technique is developed that uses a collaboration between static analysis and dynamic testing to find the first potential error but using less time and space. In the new collaboration scheme, static analysis and dynamic testing interact iteratively throughout the testing process. Static analysis provides coarse-grained flow-information to guide the dynamic testing through the relevant search space, while dynamic testing collects concrete runtime-information during the guided exploration. The concrete runtime-information provides feedback to the static analysis to refine its analysis, which is then feed forward to provide more precise guidance of the dynamic testing. The new collaborative technique is able to uncover the first concurrency-related bug in a program faster using less storage than the state-of-the-art dynamic testing-tool Java PathFinder. The implementation of the collaborative technique consists of a static-analysis module based on Soot and a dynamic-analysis module based on Java PathFinder.

Concurrency is a programming tool that is widely used in applications. Concurrent user-level threads can be used to structure the execution of a program in a uniprocessor environment and/or speed up its execution in a multiprocessor setting. Unfortunately, threads may interact with each other in unpredictable ways, often leading to performance problems that are nonexistent in the sequential domain. <br /><br /> A profiler can be used to help locate performance problems in sequential and concurrent programs. A profiler is a tool that monitors, analyzes, and visualizes the execution performance of a program to help users verify its expected behaviour, and locate its bottlenecks and hotspots. One of the important tools a profiler has at its disposal is a set of hardware counters, which are specialized CPU registers that count the occurrences of hardware events as a program executes. Hardware-event counts provide extremely precise insight into the execution behaviour of a program, and can be used to pinpoint portions of code where performance is suboptimal. <br /><br /> This thesis describes the design and implementation of <em>&micro;</em>Profiler, which is a profiler for sequential and concurrent programs written in a concurrent dialect of the C++ programming language called <em>µ</em>C++. <em>µ</em>C++ offers user-level concurrency in a uniprocessor or multiprocessor shared-memory environment. A new architecture-abstraction layer is developed, which allows <em>µ</em>Profiler to access hardware counters on multiple CPU types. As well, two new profiling metrics are presented, which use the architecture-abstraction layer to gather hardware-event counts for <em>µ</em>C++ programs. These metrics offer performance information about <em>µ</em>C++ programs that is unavailable by any other means.

Testing concurrent programs remains a difficult task due to the non-deterministic nature of concurrent execution. Many approaches have been proposed to tackle the complexity of uncovering potential concurrency bugs. Static analysis tackles the problem by analyzing a concurrent program looking for situations/patterns that might lead to possible errors during execution. In general, static analysis cannot precisely locate all possible concurrent errors. Dynamic testing examines and controls a program during its execution also looking for situations/patterns that might lead to possible errors during execution. In general, dynamic testing needs to examine all possible execution paths to detect all errors, which is intractable. Motivated by these observation, a new testing technique is developed that uses a collaboration between static analysis and dynamic testing to find the first potential error but using less time and space. In the new collaboration scheme, static analysis and dynamic testing interact iteratively throughout the testing process. Static analysis provides coarse-grained flow-information to guide the dynamic testing through the relevant search space, while dynamic testing collects concrete runtime-information during the guided exploration. The concrete runtime-information provides feedback to the static analysis to refine its analysis, which is then feed forward to provide more precise guidance of the dynamic testing. The new collaborative technique is able to uncover the first concurrency-related bug in a program faster using less storage than the state-of-the-art dynamic testing-tool Java PathFinder. The implementation of the collaborative technique consists of a static-analysis module based on Soot and a dynamic-analysis module based on Java PathFinder.

In mobile communications networks, a location management scheme is responsible for tracking mobile users. Typically, a location management scheme consists of a location update scheme and a paging scheme. Gau and Haas first proposed the concurrent search(CS) approach that could simultaneously locate a number of mobile users in mobile communications networks. We propose to use the theory of the discrete-time Markov chain to analyze the performance of the concurrent search approach. In particular, we concentrate on the worst case in which each mobile user appears equally likely in all the cells of the network. We analyze the average paging delay, the call blocking probability and the system size. We show that our analytical results are consistent with the simulation results of the concurrent search.

Thesis (M.S. in M.E.)--School of Mechanical Engineering, Georgia Institute of Technology, 2004. Directed by Farrokh Mistree. / Includes bibliographical references (leaves 396-399).

With the increasing demand of fast-paced and hybrid manufacturing processes in modern industry, it is desirable to expedite the iterations between design and manufacturing through intelligent computational techniques. In this research, we propose a concurrent approach of this kind to streamline the design and manufacturing processes. With this approach, a CAD design is automatically analyzed in terms of its manufacturability in the early design stage. If the part is manufacturable, a set of process plans optimized in time, cost, fixture quality and tolerance satisfaction are reported in real time. If the part is not manufacturable, the potential design changes are provided for better manufacturing. In the approach, the geometric information of 3D models and the empirical knowledge in manufacturing processes, fixtures, and tolerances are combined and encapsulated into a graph-grammar based reasoning. The reasoning systematically extracts meaningful manufacturing details that later constitute complete process plans for any given solid model. The plans are then evaluated and optimized using a specially designed multi-objective best first search technique. The complete approach enables a concurrent and efficient manufacturability analysis tool that closely resembles real manufacturing planning practice. Numerous case studies with real engineering parts are presented to characterize the novelty and contributions of this approach. The optimality of the suggested plans is verified through computational comparisons, and the practicality of the plans is validated with hands-on implementations on the shop floor. / text

No description available.

No description available.

No description available.

No description available.