Thread Groups Research Articles

How to close a colpotomy? Barbed suture and conventional suture effects on soft tissue: an ex vivo pilot study

To evaluate the effects of different suture materials and techniques on soft tissue in relation to defined tensions and time points. Two bovine intestine samples, 4 × 4 cm size and ~3 mm thickness, were adapted with interrupted and continuous techniques using three types of suture materials: Vicryl (polyglactin 910), PDS II (polydioxanone), and V-Loc 180 (knotless, barbed polyglyconate). Four stitches or loops 9 mm apart with three knots, and 10 mm end length were performed by one gynecologist. Forces were applied from 6 newtons (N) to 14 N continuously. Outcome measures included breakage of tissue, tearing of thread, and shortening of the end length of thread. They were evaluated immediately and then at first, third, and fifth minute. Tissue breakage using No. 3/0 suture materials appears in the applied force from 10 N. polydioxanone causes more tissue tearing than polyglactin 910. The least to withstand tension is knotless polyglyconate. Interrupted stitches hold the sutured sites better than continuous stitches in all groups of threads. Shortening of the knotless polyglyconate end length by half took place with 6 N force. Simulating reparation of colpotomy, the ex vivo study supports that polyglactin 910 appears better in holding soft tissue than polydioxanone and knotless polyglyconate.

An Identification Method of Related Group of Threads for a Recent Bug Thread by Peak Characteristics of Similarities

This paper addresses identifying a related group of threads for a recent bug thread posted by a developer in the forum of open source software. A typical approach is to identify as the group of threads that is much similar to the recent bug thread. However, most of recent bug threads that are not related to any groups of threads are wrongly identified. Focusing on the peak characteristics that similarities to related group of threads are much higher than similarities to others, the proposed method identifies whether recent bug threads are related to a group of threads by Support Vector Machine with the peak characteristics of similarities. Experimental results show that the proposed method can keep the recall rate of 76% and improve the precision rate by 49% compared to the method using only thresholds for similarities.

Coherent parallel hashing

Recent spatial hashing schemes hash millions of keys in parallel, compacting sparse spatial data in small hash tables while still allowing for fast access from the GPU. Unfortunately, available schemes suffer from two drawbacks: Multiple runs of the construction process are often required before success, and the random nature of the hash functions decreases access performance. We introduce a new parallel hashing scheme which reaches high load factor with a very low failure rate. In addition our scheme has the unique advantage to exploit coherence in the data and the access patterns for faster performance. Compared to existing approaches, it exhibits much greater locality of memory accesses and consistent execution paths within groups of threads. This is especially well suited to Computer Graphics applications, where spatial coherence is common. In absence of coherence our scheme performs similarly to previous methods, but does not suffer from construction failures. Our scheme is based on the Robin Hood scheme modified to quickly abort queries of keys that are not in the table, and to preserve coherence. We demonstrate our scheme on a variety of data sets. We analyze construction and access performance, as well as cache and threads behavior.

Tuning collective communication for Partitioned Global Address Space programming models

Partitioned Global Address Space (PGAS) languages offer programmers the convenience of a shared memory programming style combined with locality control necessary to run on large-scale distributed memory systems. Even within a PGAS language programmers often need to perform global communication operations such as broadcasts or reductions, which are best performed as collective operations in which a group of threads work together to perform the operation. In this paper we consider the problem of implementing collective communication within PGAS languages and explore some of the design trade-offs in both the interface and implementation. In particular, PGAS collectives have semantic issues that are different than in send–receive style message passing programs, and different implementation approaches that take advantage of the one-sided communication style in these languages. We present an implementation framework for PGAS collectives as part of the GASNet communication layer, which supports shared memory, distributed memory and hybrids. The framework supports a broad set of algorithms for each collective, over which the implementation may be automatically tuned. Finally, we demonstrate the benefit of optimized GASNet collectives using application benchmarks written in UPC, and demonstrate that the GASNet collectives can deliver scalable performance on a variety of state-of-the-art parallel machines including a Cray XT4, an IBM BlueGene/P, and a Sun Constellation system with InfiniBand interconnect.

TLSync

As the number of cores on a single-chip grows, scalable barrier synchronization becomes increasingly difficult to implement. In software implementations, such as the tournament barrier, a larger number of cores results in a longer latency for each round and a larger number of rounds. Hardware barrier implementations require significant dedicated wiring, e.g., using a reduction (arrival) tree and a notification (release) tree, and multiple instances of this wiring are needed to support multiple barriers (e.g., when concurrently executing multiple parallel applications). This paper presents TLSync, a novel hardware barrier implementation that uses the high-frequency part of the spectrum in a transmission-line broadcast network, thus leaving the transmission line network free for non-modulated (baseband) data transmission. In contrast to other implementations of hardware barriers, TLSync allows multiple thread groups to each have its own barrier. This is accomplished by allocating different bands in the radio-frequency spectrum to different groups. Our circuit-level and electromagnetic models show that the worst-case latency for a TLSync barrier is 4ns to 10ns, depending on the size of the frequency band allocated to each group, and our cycle-accurate architectural simulations show that low-latency TLSync barriers provide significant performance and scalability benefits to barrier-intensive applications.

Filament Thread-like Structures and Their Small-amplitude Oscillations

Thanks to gradually improving observational capabilities, both from space and ground-based observatories, it is now generally accepted that thin threads (width ∼200 km) constitute the building blocks of solar filaments and prominences. At ultra-small scales, high quality image sequences show a non-static picture of filaments and reveal that their oscillatory behavior is an important dynamic feature of these structures. Filament seismology sheds light on the internal magnetic structures of filaments and their interactions with surrounding solar regions. Understanding the overall magnetic topology of solar filaments and prominences including their small-scale thread-like structures is essential in interpretation and understanding of their oscillations. For this reason we aim here to present an update of the dynamic and spatial structures of prominences and filaments as inferred from high resolution observations in the past decennia. Some constraints in high resolution observations are addressed. Our review focuses mainly on the observational aspects and aims to summarize recent oscillation studies of individual filament threads and groups of threads. Finally, some theoretical interpretations of oscillations of filament threads and the inferred physical conditions of filament plasma are also discussed.

PROPAGATION OF NONADIABATIC MAGNETOACOUSTIC WAVES IN A THREADED PROMINENCE WITH MASS FLOWS

High-resolution observations of solar filaments suggest the presence of groups of prominence threads, i.e., the fine structures of solar prominences, which oscillate coherently (in phase). In addition, mass flows along threads have been often observed. Here, we investigate the effect of mass flows on the collective fast and slow nonadiabatic magnetoacoustic wave modes supported by systems of prominence threads. Prominence fine structures are modeled as parallel, homogeneous, and infinite cylinders embedded in a coronal environment. The magnetic field is uniform and parallel to the axis of threads. Configurations of identical and nonidentical threads are both explored. We apply the T-matrix theory of acoustic scattering to obtain the oscillatory frequency and the eigenfunctions of linear magnetosonic disturbances. We find that the existence of wave modes with a collective dynamics, i.e., those that produce significant perturbations in all threads, is only possible when the Doppler-shifted individual frequencies of threads are very similar. This can be only achieved for very particular values of the plasma physical conditions and flow velocities within threads.

A compiler-directed data prefetching scheme for chip multiprocessors

Data prefetching has been widely used in the past as a technique for hiding memory access latencies. However, data prefetching in multi-threaded applications running on chip multiprocessors (CMPs) can be problematic when multiple cores compete for a shared on-chip cache (L2 or L3). In this paper, we (i) quantify the impact of conventional data prefetching on shared caches in CMPs. The experimental data collected using multi-threaded applications indicates that, while data prefetching improves performance in small number of cores, its benefits reduce significantly as the number of cores is increased, that is, it is not scalable; (ii) identify harmful prefetches as one of the main contributors for degraded performance with a large number of cores; and (iii) propose and evaluate a compiler-directed data prefetching scheme for shared on-chip cache based CMPs. The proposed scheme first identifies program phases using static compiler analysis, and then divides the threads into groups within each phase and assigns a customized prefetcher thread (helper thread) to each group of threads. This helps to reduce the total number of prefetches issued, prefetch overheads, and negative interactions on the shared cache space due to data prefetches, and more importantly, makes compiler-directed prefetching a scalable optimization for CMPs. Our experiments with the applications from the SPEC OMP benchmark suite indicate that the proposed scheme improves overall parallel execution latency by 18.3% over the no-prefetch case and 6.4% over the conventional data prefetching scheme (where each core prefetches its data independently), on average, when 12 cores are used. The corresponding average performance improvements with 24 cores are 16.4% (over the no-prefetch case) and 11.7% (over the conventional prefetching case). We also demonstrate that the proposed scheme is robust under a wide range of values of our major simulation parameters, and the improvements it achieves come very close to those that can be achieved using an optimal scheme.

The future in your pocket

There is a growing sentiment among academics in computing that a shift to multicore processors in commodity computers will demand that all programmers become parallel programmers. This is because future general-purpose processors are not likely to improve the performance of a single thread of execution; instead, the presence of multiple processor cores on a CPU will improve the performance of groups of threads. In this article, I argue that there is another trend underway, namely integration, which will have a greater near-term impact on developers of system software and applications. This integration, and its likely impact on general-purpose computers, is clearly illustrated in the architecture of modern mobile phones

Hierarchical Scheduling for Symmetric Multiprocessors

Hierarchical scheduling has been proposed as a scheduling technique to achieve aggregate resource partitioning among related groups of threads and applications in uniprocessor and packet scheduling environments. Existing hierarchical schedulers are not easily extensible to multiprocessor environments because 1) they do not incorporate the inherent parallelism of a multiprocessor system while resource partitioning and 2) they can result in unbounded unfairness or starvation if applied to a multiprocessor system in a naive manner. In this paper, we present hierarchical multiprocessor scheduling (H-SMP), a novel hierarchical CPU scheduling algorithm designed for a symmetric multiprocessor (SMP) platform. The novelty of this algorithm lies in its combination of space and time multiplexing to achieve the desired bandwidth partition among the nodes of the hierarchical scheduling tree. This algorithm is also characterized by its ability to incorporate existing proportional-share algorithms as auxiliary schedulers to achieve efficient hierarchical CPU partitioning. In addition, we present a generalized weight feasibility constraint that specifies the limit on the achievable CPU bandwidth partitioning in a multiprocessor hierarchical framework and propose a hierarchical weight readjustment algorithm designed to transparently satisfy this feasibility constraint. We evaluate the properties of H-SMP using hierarchical surplus fair scheduling (H-SFS), an instantiation of H-SMP that employs surplus fair scheduling (SFS) as an auxiliary algorithm. This evaluation is carried out through a simulation study that shows that H-SFS provides better fairness properties in multiprocessor environments as compared to existing algorithms and their naive extensions.

The learners’ experience of variation: following students’ threads of learning physics in computer simulation sessions

This article attempts to describe students’ process of learning physics using the notion of experiencing variation as the basic mechanism for learning, and thus explores what variation, with respect to a particular object of learning, that students experience in their process of constituting understanding. Theoretically, the analysis relies on analytic tools from the phenomenographic research tradition, and the recent group of studies colloquially known as the variation theory of learning, having the notion of experiencing variation as a key for learning at its core. Empirically, the study relies on video and audio recordings of seven pairs of students interacting in a computer-simulation learning environment featuring Bohr’s model of the atom. The data was analysed on a micro-level for the emergence of student-recognised variation, depicted in terms of ‘threads of learning’. This was done by linking variation around aspects of the object of learning present in the situation, and attended to by the students, to new ways of seeing—characterised as an expanding anatomy of awareness, and hence as learning. The students’ threads of learning are characterised in terms of two stages of learning progress: (1) discerning variation, and (2) constituting meaning from this experience of variation (experienced as holistically relevant in the students’ conceptual domain of physics and the Bohr model). Two groups of threads of learning were identified: one where the variation experienced by students was within an aspect of the object of learning, and one where variation was across several aspects.

Operating system support for execution time budgets for thread groups

The recent Ada 2005 standard introduced a number of new real-time services, with the capability of creating and managing execution time budgets for groups of tasks. This capability has many practical applications in real-time systems in general, and therefore it is also interesting for real-time operating systems. In this paper we present an implementation of thread group budgets inside a POSIX real-operating system, which can be used to implement the new Ada 2005 services. The architecture and details of the implementation are shown, as they may be useful to other implementers of this functionality defined in the new standard.

CCJ: object‐based message passing and collective communication in Java

AbstractCCJ is a communication library that adds MPI‐like message passing and collective operations to Java. Rather than trying to adhere to the precise MPI syntax, CCJ aims at a clean integration of communication into Java's object‐oriented framework. For example, CCJ uses thread groups to support Java's multithreading model and it allows any data structure (not just arrays) to be communicated. CCJ is implemented entirely in Java, on top of RMI, so it can be used with any Java virtual machine. The paper discusses three parallel Java applications that use collective communication. It compares the performance (on top of a Myrinet cluster) of CCJ, RMI and mpiJava versions of these applications and also compares their code complexity. A detailed performance comparison between CCJ and mpiJava is given using the Java Grande Forum MPJ benchmark suite. The results show that neither CCJ's object‐oriented design nor its implementation on top of RMI impose a performance penalty on applications compared to their mpiJava counterparts. The source of CCJ is available from our Web site http://www.cs.vu.nl/manta. Copyright © 2003 John Wiley & Sons, Ltd.

Automatic Multilevel Parallelization Using OpenMP

In this paper we describe the extension of the CAPO parallelization support tool to support multilevel parallelism based on OpenMP directives. CAPO generates OpenMP directives with extensions supported by the NanosCompiler to allow for directive nesting and definition of thread groups. We report some results for several benchmark codes and one full application that have been parallelized using our system.

Security in the Ajanta mobile agent system

AbstractA mobile agent is an object which can autonomously migrate in a distributed system to perform tasks on behalf of its creator. Security issues in regard to the protection of host resources, as well as the agent themselves, raise significant obstacles in practical applications of the agent paradigm. This article describes the security architecture of Ajanta, a Java‐based system for mobile agent programming. This architecture provides mechanisms to protect server resources from malicious agents, agent data from tampering by malicious servers and communication channels during its travel, and protection of name service data and the global namespace. We present here a proxy based mechanism for secure access to server resources by agents. Using Java's class loader model and thread group mechanism, isolated execution domains are created for agents at a server. An agent can contain three kinds of protected objects: read‐only objects whose tampering can be detected, encrypted objects for specific servers, and a secure append‐only log of objects. A generic authentication protocol is used for all client–server interactions when protection is required. Using this mechanism, the security model of Ajanta enforces protection of namespaces, and secure execution of control primitives such as agent recall or abort. Ajanta also supports communication between agents using RMI, which can be controlled if required by the servers' security policies. Copyright © 2001 John Wiley & Sons, Ltd.

NanosCompiler: supporting flexible multilevel parallelism exploitation in OpenMP

This paper describes the support provided by the NanosCompiler to nested parallelism in OpenMP. The NanosCompiler is a source-to-source parallelizing compiler implemented around a hierarchical internal program representation that captures the parallelism expressed by the user (through OpenMP directives and extensions) and the parallelism automatically discovered by the compiler through a detailed analysis of data and control dependences. The compiler is finally responsible for encapsulating work into threads, establishing their execution precedences and selecting the mechanisms to execute them in parallel. The NanosCompiler enables the experimentation with different work allocation strategies for nested parallel constructs. Some OpenMP extensions are proposed to allow the specification of thread groups and precedence relations among them. Copyright © 2000 John Wiley & Sons, Ltd.

JRes

With the spread of the Internet the computing model on server systems is undergoing several important changes. Recent research ideas concerning dynamic operating system extensibility are finding their way into the commercial domain, resulting in designs of extensible databases and Web servers. In addition, both ordinary users and service providers must deal with untrusted downloadable executable code of unknown origin and intentions.Across the board, Java has emerged as the language of choice for Internet-oriented software. We argue that, in order to realize its full potential in applications dealing with untrusted code, Java needs a flexible resource accounting interface. The design and prototype implementation of such an interface --- JRes --- is presented in this paper. The interface allows to account for heap memory, CPU time, and network resources consumed by individual threads or groups of threads. JRes allows limits to be set on resources available to threads and it can invoke callbacks when these limits are exceeded. The JRes prototype described in this paper is implemented on top of standard Java virtual machines and requires only a small amount of native code.

The computer construction of weaving designs

Weaving is the art of forming a fabric by interlacing threads at right angles and is performed on a frame called a loom. The threads at right angles to the weaver are the warp threads, and the threads parallel to the weaver and which are inserted between the warp threads are the weft threads. The warp threads are alternately raised and lowered to create a shed through which the weft thread is inserted. They are fastened to a warp roller at the back of the loom, pass over a back beam and through the eyes of vertical wires called heddles, and then through reeds which help keep them parallel and in the proper sequence. The woven cloth passes over a front beam and is then wound onto a cloth roller. Each row of heddles is attached to a harness, and there may be two, four, eight or more harnesses. Each warp thread passes through a heddle on any one of the harnesses. The harnesses are raised and lowered by treadles which are worked by the fingers on a table loom and by the feet on a foot loom. Harnesses may be tied together so that more than one may be operated by the same treadle. As a group of warp threads is raised or lowered by the treddles, the shuttle with the weft thread is inserted into the shed between the two groups of threads.

Data‐Parallel Programming in a Multithreaded Environment

Research on programming distributed memory multiprocessors has resulted in a well‐understood programming model, namely data‐parallel programming. However, data‐parallel programming in a multithreaded environment is far less understood. For example, if multiple threads within the same process belong to different data‐parallel computations, then the architecture, compiler, or run‐time system must ensure that relative indexing and collective operations are handled properly and efficiently. We introduce a run‐time‐based solution for data‐parallel programming in a distributed memory environment that handles the problems of relative indexing and collective communications among thread groups. As a result, the data‐parallel programming model can now be executed in a multithreaded environment, such as a system using threads to support both task and data parallelism.

Locality, causality and continuations

Concurrency and distribution are topics exacerbated by the omnipresence of Internet. Although many languages address these topics, few offer a real opportunity to control and coordinate widely spread dynamic computations. This paper presents such a language and its prominent features. Besides explaining the software architecture of the implementation (based on objects and generic functions), it also presents an original coherency protocol for shared mutable variables. We first recall, in Section 1, the main features of our Scheme-based, concurrent, distributed and computation-oriented language already presented in more details and examples in [QD93]. Section 2 explains how to systematically implement a concurrent and distributed interpreter for that language, using a set of program transformations combining Abstract Continuation Passing Style (ACPS) and Object-Oriented Lifting. The originality of this implementation is that it chiefly uses objects and generic functions in a style that allows to concentrate the problems related to concurrency and migration of computations into the sole discriminating behavior of generic functions. ACPS is not only used to reify continuations but also to enforce locality of computations in presence of distal objects. In Section 3, we propose a new (to our knowledge) protocol to manage shared mutable variables. This protocol enhances [MSRN92], does not require atomic broadcast, tolerates short communication breakdowns and uses bounded circular clocks. This result comes from the use of a distributed GC (which allows us to maintain an approximation of Global Virtual Time) and from the exploitation of causality as stated by continuations. To give a continuation a value (and a store) clearly expresses that the computations that are present in the continuation causally depend on the invoker of the continuation. Finally the computation-orientation of our language and mainly the ability to control groups of threads, concurrently running on multiple sites for the completion of the evaluation of a single expression, is shortly sketched in Section 4. As usual, related works and conclusions end this paper.