Explicit Thread Research Articles

Entanglement Length Scale Separates Threading from Branching of Unknotted and Non-concatenated Ring Polymers in Melts.

Current theories on the conformation and dynamics of unknotted and non-concatenated ring polymers in melt conditions describe each ring as a tree-like double-folded object. While evidence from simulations supports this picture on a single ring level, other works show pairs of rings also thread each other, a feature overlooked in the tree theories. Here we reconcile this dichotomy using Monte Carlo simulations of the ring melts with different bending rigidities. We find that rings are double-folded (more strongly for stiffer rings) on and above the entanglement length scale, while the threadings are localized on smaller scales. The different theories disagree on the details of the tree structure, i.e., the fractal dimension of the backbone of the tree. In the stiffer melts we find an indication of a self-avoiding scaling of the backbone, while more flexible chains do not exhibit such a regime. Moreover, the theories commonly neglect threadings and assign different importance to the impact of the progressive constraint release (tube dilation) on single ring relaxation due to the motion of other rings. Despite that each threading creates only a small opening in the double-folded structure, the threading loops can be numerous and their length can exceed substantially the entanglement scale. We link the threading constraints to the divergence of the relaxation time of a ring, if the tube dilation is hindered by pinning a fraction of other rings in space. Current theories do not predict such divergence and predict faster than measured diffusion of rings, pointing at the relevance of the threading constraints in unpinned systems as well. Revision of the theories with explicit threading constraints might elucidate the validity of the conjectured existence of topological glass.

High-Performance, Graphics Processing Unit-Accelerated Fock Build Algorithm.

We present a high-performance, GPU (graphics processing unit)-accelerated algorithm for building the Fock matrix. The algorithm is designed for efficient calculations on large molecular systems and uses a novel dynamic load balancing scheme that maximizes the GPU throughput and avoids thread divergence that could occur due to integral screening. Additionally, the code adopts a novel ERI digestion algorithm that exploits all forms of permutational symmetry, combines efficiently the evaluation of both Coulomb and exchange terms together, and eliminates explicit thread synchronization requirements. Performance results obtained using a number of large molecules reveal remarkable speedups up to 24.4× with respect to the QUICK GPU code and up to 237× with respect to the GAMESS CPU parallel code.

Geometric aspects of holographic bit threads

We revisit the recent reformulation of the holographic prescription to compute entanglement entropy in terms of a convex optimization problem, introduced by Freedman and Headrick. According to it, the holographic entanglement entropy associated to a boundary region is given by the maximum flux of a bounded, divergenceless vector field, through the corresponding region. Our work leads to two main results: (i) We present a general algorithm that allows the construction of explicit thread configurations in cases where the minimal surface is known. We illustrate the method with simple examples: spheres and strips in vacuum AdS, and strips in a black brane geometry. Studying more generic bulk metrics, we uncover a sufficient set of conditions on the geometry and matter fields that must hold to be able to use our prescription. (ii) Based on the nesting property of holographic entanglement entropy, we develop a method to construct bit threads that maximize the flux through a given bulk region. As a byproduct, we are able to construct more general thread configurations by combining (i) and (ii) in multiple patches. We apply our methods to study bit threads which simultaneously compute the entanglement entropy and the entanglement of purification of mixed states and comment on their interpretation in terms of entanglement distillation. We also consider the case of disjoint regions for which we can explicitly construct the so-called multi-commodity flows and show that the monogamy property of mutual information can be easily illustrated from our constructions.

Performance Optimization and Modeling of Fine-Grained Irregular Communication in UPC

The Unified Parallel C (UPC) programming language offers parallelism via logically partitioned shared memory, which typically spans physically disjoint memory subsystems. One convenient feature of UPC is its ability to automatically execute between-thread data movement, such that the entire content of a shared data array appears to be freely accessible by all the threads. The programmer friendliness, however, can come at the cost of substantial performance penalties. This is especially true when indirectly indexing the elements of a shared array, for which the induced between-thread data communication can be irregular and have a fine-grained pattern. In this paper, we study performance enhancement strategies specifically targeting such fine-grained irregular communication in UPC. Starting from explicit thread privatization, continuing with block-wise communication, and arriving at message condensing and consolidation, we obtained considerable performance improvement of UPC programs that originally require fine-grained irregular communication. Besides the performance enhancement strategies, the main contribution of the present paper is to propose performance models for the different scenarios, in the form of quantifiable formulas that hinge on the actual volumes of various data movements plus a small number of easily obtainable hardware characteristic parameters. These performance models help to verify the enhancements obtained, while also providing insightful predictions of similar parallel implementations, not limited to UPC, that also involve between-thread or between-process irregular communication. As a further validation, we also apply our performance modeling methodology and hardware characteristic parameters to an existing UPC code for solving a 2D heat equation on a uniform mesh.

OpenCL을 활용한 CPU와 GPU 에서의 CMMB LDPC 복호기 병렬화

Recently, Open Computing Language (OpenCL) has been proposed to provide a framework that supports heterogeneous computing platforms. By using an OpenCL framework, digital communication systems can support various protocols in a unified computing environment to achieve both high portability and high performance. This article introduces a parallel software decoder of Low Density Parity Check (LDPC) codes for China Multimedia Mobile Broadcasting (CMMB) on a heterogeneous platform. Each step of LDPC decoding has different parallelization characteristics. In this paper, steps suitable for task-level parallelization are executed on the CPU, and steps suitable for data-level parallelization are processed by the GPU. To improve the performance of the proposed OpenCL kernels for LDPC decoding operations, explicit thread scheduling, loop-unrolling, and effective data transfer techniques are applied. The proposed LDPC decoder achieves high performance by using heterogeneous multi-core processors on a unified computing framework.

Parallel LDPC Decoding on a Heterogeneous Platform using OpenCL

Modern mobile devices are equipped with various accelerated processing units to handle computationally intensive applications; therefore, Open Computing Language (OpenCL) has been proposed to fully take advantage of the computational power in heterogeneous systems. This article introduces a parallel software decoder of Low Density Parity Check (LDPC) codes on an embedded heterogeneous platform using an OpenCL framework. The LDPC code is one of the most popular and strongest error correcting codes for mobile communication systems. Each step of LDPC decoding has different parallelization characteristics. In the proposed LDPC decoder, steps suitable for task-level parallelization are executed on the multi-core central processing unit (CPU), and steps suitable for data-level parallelization are processed by the graphics processing unit (GPU). To improve the performance of OpenCL kernels for LDPC decoding operations, explicit thread scheduling, vectorization, and effective data transfer techniques are applied. The proposed LDPC decoder achieves high performance and high power efficiency by using heterogeneous multi-core processors on a unified computing framework.

Understanding energy behaviors of thread management constructs

Java programmers are faced with numerous choices in managing concurrent execution on multicore platforms. These choices often have different trade-offs (e.g., performance, scalability, and correctness guarantees). This paper analyzes an additional dimension, energy consumption. It presents an empirical study aiming to illuminate the relationship between the choices and settings of thread management constructs and energy consumption. We consider three important thread management constructs in concurrent programming: explicit thread creation, fixed-size thread pooling, and work stealing. We further shed light on the energy/performance trade-off of three ``tuning knobs'' of these constructs: the number of threads, the task division strategy, and the characteristics of processed data. Through an extensive experimental space exploration over real-world Java programs, we produce a list of findings about the energy behaviors of concurrent programs, which are not always obvious. The study serves as a first step toward improving energy efficiency of concurrent programs on parallel architectures.

The cruel poetics of Morrissey

Drawing on existential phenomenology, particularly Heidegger’s analytic of Dasein, and combining it with a developmental perspective, the paper focuses on those moments of crisis, in which a self faces the question of its own truth, and in the process posits the conditions for disclosing key aspects about the world and society. Late adolescence and early adulthood are the ‘ages of life’ in which such possibility of disclosure occurs most eminently, and this is relayed expressively and reflectively, the paper further argues, in the few examples of popular music that act as genuine outlets for young people’s desires and anxieties. The poetic work of Morrissey is a particularly eloquent case in point. However, a succinct analysis of Morrissey’s poetics reveals that underneath the explicit thread of sexuality, it is violence and cruelty that shape the young soul into becoming a channel for world and social disclosure.

Yada: Straightforward parallel programming

Now that multicore chips are common, providing an approach to parallel programming that is usable by regular programmers has become even more important. This cloud has one silver lining: providing useful speedup on a program is useful in and of itself, even if the resulting performance is lower than the best possible parallel performance on the same program. To help achieve this goal, Yada is an explicitly parallel programming language with sequential semantics. Explicitly parallel, because we believe that programmers need to identify how and where to exploit potential parallelism, but sequential semantics so that programmers can understand and debug their parallel programs in the way that they already know, i.e. as if they were sequential. The key new idea in Yada is the provision of a set of types that support parallel operations while still preserving sequential semantics. Beyond the natural read-sharing found in most previous sequential-like languages, Yada supports three other kinds of sharing. Writeonce locations support a single write and multiple reads, and two kinds of sharing for locations updated with an associative operator generalise the reduction and parallel-prefix operations found in many data-parallel languages. We expect to support other kinds of sharing in the future. We have evaluated our Yada prototype on eight algorithms and four applications, and found that programs require only a few changes to get useful speedups ranging from 2.2 to 6.3 on an 8-core machine. Yada performance is mostly comparable to parallel implementations of the same programs using OpenMP or explicit threads.

Asserting and checking determinism for multithreaded programs

The trend towards processors with more and more parallel cores is increasing the need for software that can take advantage of parallelism. The most widespread method for writing parallel software is to use explicit threads. Writing correct multithreaded programs, however, has proven to be quite challenging in practice. The key difficulty is nondeterminism. The threads of a parallel application may be interleaved nondeterministically during execution. In a buggy program, nondeterministic scheduling can lead to nondeterministic results—where some interleavings produce the correct result while others do not. We propose an assertion framework for specifying that regions of a parallel program behave deterministically despite nondeterministic thread interleaving. Our framework allows programmers to write assertions involving pairs of program states arisingfrom different parallel schedules. We describe an implementation of our deterministic assertions as a library for Java, and evaluate the utility of our specifications on a number of parallel Java benchmarks. We found specifying deterministic behavior to be quite simple using our assertions. Further, in experiments with our assertions, we were able to identify two races as true parallelism errors that lead to incorrect non-deterministic behavior. These races were distinguished from a number of benign races in the benchmarks.

Effective performance measurement and analysis of multithreaded applications

Understanding why the performance of a multithreaded program does not improve linearly with the number of cores in a shared-memory node populated with one or more multicore processors is a problem of growing practical importance. This paper makes three contributions to performance analysis of multithreaded programs. First, we describe how to measure and attribute parallel idleness , namely, where threads are stalled and unable to work. This technique applies broadly to programming models ranging from explicit threading ( e.g. , Pthreads) to higher-level models such as Cilk and OpenMP. Second, we describe how to measure and attribute parallel overhead -- when a thread is performing miscellaneous work other than executing the user's computation. By employing a combination of compiler support and post-mortem analysis, we incur no measurement cost beyond normal profiling to glean this information. Using idleness and overhead metrics enables one to pinpoint areas of an application where concurrency should be increased (to reduce idleness), decreased (to reduce overhead), or where the present parallelization is hopeless (where idleness and overhead are both high). Third, we describe how to measure and attribute arbitrary performance metrics for high-level multithreaded programming models, such as Cilk. This requires bridging the gap between the expression of logical concurrency in programs and its realization at run-time as it is adaptively partitioned and scheduled onto a pool of threads. We have prototyped these ideas in the context of Rice University's HPCToolkit performance tools. We describe our approach, implementation, and experiences applying this approach to measure and attribute work, idleness, and overhead in executions of Cilk programs.

A scheduling framework for general-purpose parallel languages

The trend in microprocessor design toward multicore and manycore processors means that future performance gains in software will largely come from harnessing parallelism. To realize such gains, we need languages and implementations that can enable parallelism at many different levels. For example, an application might use both explicit threads to implement course-grain parallelism for independent tasks and implicit threads for fine-grain data-parallel computation over a large array. An important aspect of this requirement is supporting a wide range of different scheduling mechanisms for parallel computation. In this paper, we describe the scheduling framework that we have designed and implemented for Manticore, a strict parallel functional language. We take a micro-kernel approach in our design: the compiler and runtime support a small collection of scheduling primitives upon which complex scheduling policies can be implemented. This framework is extremely flexible and can support a wide range of different scheduling policies. It also supports the nesting of schedulers, which is key to both supporting multiple scheduling policies in the same application and to hierarchies of speculative parallel computations. In addition to describing our framework, we also illustrate its expressiveness with several popular scheduling techniques. We present a (mostly) modular approach to extending our schedulers to support cancellation. This mechanism is essential for implementing eager and speculative parallelism. We finally evaluate our framework with a series of benchmarks and an analysis.

Information and discrimination in pairwise contact potentials

We examine the information-theoretic characteristics of statistical potentials that describe pairwise long-range contacts between amino acid residues in proteins. In our work, we seek to map out an efficient information-based strategy to detect and optimally utilize the structural information latent in empirical data, to make contact potentials, and other statistically derived folding potentials, more effective tools in protein structure prediction. Foremost, we establish fundamental connections between basic information-theoretic quantities (including the ubiquitous Z-score) and contact "energies" or scores used routinely in protein structure prediction, and demonstrate that the informatic quantity that mediates fold discrimination is the total divergence. We find that pairwise contacts between residues bear a moderate amount of fold information, and if optimized, can assist in the discrimination of native conformations from large ensembles of native-like decoys. Using an extensive battery of threading tests, we demonstrate that parameters that affect the information content of contact potentials (e.g., choice of atoms to define residue location and the cut-off distance between pairs) have a significant influence in their performance in fold recognition. We conclude that potentials that have been optimized for mutual information and that have high number of score events per sequence-structure alignment are superior in identifying the correct fold. We derive the quantity "information product" that embodies these two critical factors. We demonstrate that the information product, which does not require explicit threading to compute, is as effective as the Z-score, which requires expensive decoy threading to evaluate. This new objective function may be able to speed up the multidimensional parameter search for better statistical potentials. Lastly, by demonstrating the functional equivalence of quasi-chemically approximated "energies" to fundamental informatic quantities, we make statistical potentials less dependent on theoretically tenuous biophysical formalisms and more amenable to direct bioinformatic optimization.

Distributed strategic interleaving with load balancing

In a previous paper, we developed an algebraic theory of threads, interleaving of threads, and interaction of threads with services. In the current paper, we assume that the threads and services are distributed over the nodes of a network. We extend the theory developed so far to the distributed case by introducing distributed interleaving strategies that support explicit thread migration and see to load balancing or capability searching by implicit thread migration. The extension to the distributed case provides insight into details of multi-threading that come up in a networked environment.

Information Management and Learning in Computer Conferences: Coping with Irrelevant and Unconnected Messages

The present study examines how learnersinteract with one another within the context ofa computer conference for the purposes ofpassing a test. In a faked computer conferencewith predetermined messages, both the number ofmessages irrelevant to the topic, and theexplicit threading of messages were varied in a2 × 2 design (n = 54). Subjects participated in anasynchronous fashion over a course of fourlog-in sessions. In general, learners indicateda fairly consistent pattern of reception. Theyopened virtually all messages, grouped them ina non-chronological order, and processed themaccording to their topic relevance. Thispattern was also mediated by the conferencecharacteristics. Explicit threading led tosequences of message readings that were morecontent oriented. Similarly, fewer irrelevantmessages lead to prolonged reading times ofrelevant messages. Whereas learning success wasnot affected by conference characteristics,explicitly threaded messages decreased theperceived cognitive demands.

An Interview with Elizabeth Alexander

An Interview with Elizabeth Alexander Christine Phillip (bio) Click for larger view View full resolution Elizabeth Alexander photo by Barbara Kigosi. This interview was conducted via telephone on Thursday, February 22, 1996. CHRISTINE PHILLIP: You have added a new dimension to your writing. Already established as a poet and essayist, you have now ventured into drama. Your first play, Diva Studies, was staged by the Yale Drama School in May 1996. Does the theater offer new avenues for creation and expression not available in other genres? ELIZABETH ALEXANDER: It absolutely does. First of all, in my poetry, I am always borrowing what I think of as poetic vernacular language. I am fascinated by the distinctly wonderful ways that people talk, particularly the ways that black people can talk. So what seems exciting about working in the theater is that borrowed language is put back into live bodies when actors embody the language. The issue of audience is also important. Those who love poetry are true devotees. A poetry reading audience is rarely as large as most theater audiences. When a book of poems is published, probably a thousand copies are printed, even if the book’s hand to hand life is greater than that. But hundreds of people see a play on a single night. Of course, what is completely different about working in the theater is that it is collaborative. Even though I have found that to be difficult, as I am used to working in solitude, it’s wonderful to receive other peoples’ expertise to help realize your work. There is something very moving to me about other people devoting their skills to making my words live. I am actively learning about that difficult, exciting new dimension of writing. PHILLIP: As a poet and essayist, you have a great deal of control over your work. Do you have that same kind of control as a playwright? What is it like to see your work manifested through the eyes and voices of others? ALEXANDER: When I got to see, for the first time, the beautiful costume drawings and model sets the designers had made, it was completely thrilling. As a poet, I don’t talk about my work very much at all. In fact, I think that when you talk about poetry before you’ve written it, it kills it. Talk is only a substitute for writing, and the only thing you are supposed to be doing is writing. The part that is perhaps the hardest is that I’ve had to get used to talking about my work before it’s finished, showing my work to people, to the director, Leah Gardiner, and the dramaturge, Elizabeth Ackerman, before it is finished. Aside from simply getting over the ego part—I don’t [End Page 493] like to let my work go until it’s polished—it’s unsettling. I’m really, really used to pouring all my energy into making the work so that it can speak for itself. What you get back from collaboration is that the dramaturge and director have come to know my characters, they’ve helped me see who those characters are through their eyes. Also, what I have found is that going from the very small scale, miniaturist, meticulous world of poetry, it’s hard for me this first go ‘round to hold on to the architecture of an entire full-length play. So my collaborators have helped me understand the overall structure and the overall curvature of what it is I’m trying to make, and then make explicit threads that tie it all together. That training is a different kind of mind training than mine, which is more language-based and image-generated. And, of course, there’s nothing like watching wonderful actors bring your words to life. PHILLIP: What sparked your interest in the theater, and what is your association with the Yale School of Drama? ALEXANDER: Those two answers are related. My interest in theater has been lifelong because I grew up dancing ballet and then modern dance quite seriously through my teenage years. Then when I was in college, I did some choreography and a little bit of...

A general model for concurrent and distributed object-oriented programming

This summary presents a general model supporting object-oriented programming in concurrent as well as distributed environments.The model combines the advantages of remote procedure calls with those of message passing.It relies on the following concepts:• All objects are not active but the active entities are objects.• Asynchronous Message Passing with Data-driven synchronization.• Service mechanism allowing an explicit thread of control.