In the competitive environment, the manufacturing companies must focus on the requirements of the customers, short time-to-market, superior product quality and reducing manufacturing cost. Facing the tendency of global competition, it is impossible and uneconomic to satisfy the all demands of customers by enterprise¡¦s own resources. To survive and make profits, concurrent engineering and collaborative design have become popular approaches to product development among supply chains. Concurrent engineering and collaborative design are two systematic approaches to the integrated, concurrent design of products and their related process. According to the past study, R&D will take an expenditure of fifty percent to ninety percent of the whole product life cycle. For considering product design, manufacturing and assembly, it will improve the communication and coordination in the concurrent engineering environment, and reduce the engineering design change. In this paper we focus on the requiring of product design. We propose a process model to support collaborative product development (CPD). The required multi-disciplinary information for CPD will be handled via the processes of classification, transformation, analysis and optimization to assist the product development. This study can to reduce the conflict of different professional knowledge, and possibility the communication problem with the project, to promote the efficiency of collaborative development.

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. Multicore 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 ma- chines, 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 pro- grams more reliably and decrease the number of errors in spite of the proliferation of concurrency demanded by modern processors.

With the increasing dependency on software systems, we require them to be reliable and correct. Software testing is the predominant approach in industry for finding software errors. There has been a great advance in testing sequential programs throughout the past decades. Several techniques have been introduced with the aim of automatically generating input values such that the executions of the program with those inputs provide meaningful coverage guarantees for the program. Today, multi-threaded (concurrent) programs are becoming pervasive in the era of multiprocessor systems. The behaviour of a concurrent program depends not only on the input values but also on the way the executions of threads are interleaved. Testing concurrent programs is notoriously hard because often there are exponentially large number of interleavings of executions of threads that has to be explored. In this thesis, we propose an array of heuristicbased testing techniques for concurrent programs to prioritize a subset of interleavings and test as many of them as possible. To that end, we develop: (A) a sound and scalable technique that based on the events of an observed execution, predicts runs that might contain null-pointer dereferences. This technique explores the interleaving space (based on the observed execution) while keeping the input values fixed and can be adapted to predict other types of bugs. (B) a test generation technique that uses a set of program executions as a program under-approximation to explore both input and interleaving spaces. This technique generates tests that increase branch coverage in concurrent programs based their approximation models. (C) a new heuristic, called bounded-interference, for input/interleaving exploration. It is defined based on the notion of data-flow between threads and is parameterized by the number of interferences among threads. Testing techniques that employ this heuristic are able to provide coverage guarantees for concurrent programs (modulo interference bound). (D) a testing technique which adapts the sequential concolic testing to concurrent programs by incorporating the bounded-interference heuristic into it. The technique provides branch coverage guarantees for concurrent programs. Based on the above techniques, we have developed tools and used them to successfully find bugs in several traditional concurrency benchmarks.

No description available.

This thesis demonstrates that a knowledge representation model can provide considerable support to concurrent engineering teams, by providing a sound basis for creation of necessary software applications. This is achieved by demonstrating that use of the knowledge representation model facilitates the capture, interpretation and implementation of important aspects of the multiple, diverse types of expertise which are essential to the successful working of concurrent engineering project teams. The varieties of expertise which can be modelled as instances of the knowledge representation model range from specialist applications, which support particular aspects of design, by assisting human designers with highly focused skills and knowledge sets, to applications which specialise in management or coordination of team activities. It is shown that both these types of expertise are essential for effective working of a concurrent engineering team. Examination of the requirements of concurrent engineering team working indicate that no single artificial intelligence paradigm can provide a satisfactory basis for the whole range of possible solutions which may be provided by intelligent software applications. Hence techniques, architectures and environments to support design and development of hybrid software expertise are required, and the knowledge representation model introduced in this research is such an architecture. The versatility of the knowledge representation model is demonstrated through the design and implementation of a variety of software applications.

No description available.

Thesis (M.S.)--Montana State University--Bozeman, 2005. / Typescript. Chairperson, Graduate Committee: Shi-Jie Chen. Includes bibliographical references (leaves 67-70).

Thesis (Ph.D.)--Pennsylvania State University, 2001. / Includes bibliographical references.

No description available.

<p> Concurrent Computing has certain interesting links with Algebraic Topology. There are various geometric models for concurrent computing. We examine one geometric approach to modeling concurrency, via the notion of a locally partially ordered space. We examine a notion analogous to that of homotopy, called dihomotopy, that is compatible with a local partial order. In the category of locally partially ordered spaces and di-maps we examine the isomorphisms, which are called di-homeomorphisms. We classify all di-homeomorphic embeddings of the unit square into the Euclidean plane.</p> / Thesis / Master of Science (MSc)