Programming with Exceptions in JCilk

JCilk extends the Java language to provide call-return semantics for multithreading, much as Cilk does for C. Java's built-in thread model does not support the passing of exceptions or return values from one thread back to the "parent" thread that created it. JCilk imports Cilk's fork-join primitives spawn and sync into Java to provide procedure-call semantics for concurrent subcomputations. This paper shows how JCilk integrates exception handling with multithreading by defining semantics consistent with the existing semantics of Java's try and catch constructs, but which handle concurrency in spawned methods. JCilk's strategy of integrating multithreading with Java's exception semantics yields some surprising semantic synergies. In particular, JCilk extends Java's exception semantics to allow exceptions to be passed from a spawned method to its parent in a natural way that obviates the need for Cilk's inlet and abort constructs. This extension is "faithful" in that it obeys Java's ordinary serial semantics when executed on a single processor. When executed in parallel, however, an exception thrown by a JCilk computation signals its sibling computations to abort, which yields a clean semantics in which only a single exception from the enclosing try block is handled. The decision to implicitly abort side computations opens a Pandora's box of subsidiary linguistic problems to be resolved, however. For instance, aborting might cause a computation to be interrupted asynchronously, causing havoc in programmer understanding of code behavior. To minimize the complexity of reasoning about aborts, JCilk signals them "semisynchronously" so that abort signals do not interrupt ordinary serial code. In addition, JCilk propagates an abort signal throughout a subcomputation naturally with a built-in CilkAbort exception, thereby allowing programmers to handle clean-up by simply catching the CilkAbort exception. The semantics of JCilk allow programs with speculative computations to be programmed easily. Speculation is essential for parallelizing programs such as branch-and-bound or heuristic search. We show how JCilk's linguistic mechanisms can be used to program a solution to the "queens" problem and an implemention of a parallel alpha-beta search.Singapore-MIT Alliance (SMA

The JCilk multithreaded language

Thesis (S.M.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2005.Includes bibliographical references (p. 103-107).JCilk is a Java-based multithreaded programming language which extends Java to provide a dynamic threading model. Specifically, JCilk imports Cilk's fork-join primitives spawn and sync into Java to provide procedure-call semantics for concurrent subcomputations. More importantly, JCilk integrates exception handling with multi-threading by defining semantics consistent with Java's existing semantics of exception handling. JCilk's strategy of integrating multithreading with Java's exception semantics yields some surprising semantic synergies. In particular, JCilk extends Java's exception semantics to allow exceptions to be passed from a spawned method to its parent in a natural way that obviates the need for Cilk's inlet and abort constructs. This extension is "faithful" in that it obeys Java's ordinary serial semantics when executed on a single processor. When executed in parallel, however, an exception thrown by a JCilk computation signals its sibling computations to abort, yielding a clean semantics in which only a single exception from the enclosing try block is handled. To minimize the complexity of reasoning about aborts, JCilk signals them "semisynchronously" so that abort signals do not interrupt ordinary serial code. Because JCilk uses Java's normal exception mechanism to propagate an abort throughout a subcomputation, the programmer can handle clean-up by simply catching a thrown CilkAbort exception. This thesis documents in detail the designed semantics, the linguistic decisions we made, and their justifications. This thesis also describes the structure of JCilk compiler and how it supports the exception semantics.(cont.) Specifically, the JCilk compiler performs a two-stage compilation process to support the continuation mechanism required by the runtime system's work-stealing algorithm. By performing static analysis, the compiler generates code to support the "catchlet" and "finallet" mechanisms for handling exceptions. The design of JCilk represents joint research with John S. Danaher and Charles E. Leiserson.by I-Ting Angelina Lee.S.M

Efficient Race Detection with Futures

This paper addresses the problem of provably efficient and practically good on-the-fly determinacy race detection in task parallel programs that use futures. Prior works determinacy race detection have mostly focused on either task parallel programs that follow a series-parallel dependence structure or ones with unrestricted use of futures that generate arbitrary dependences. In this work, we consider a restricted use of futures and show that it can be race detected more efficiently than general use of futures. Specifically, we present two algorithms: MultiBags and MultiBags+. MultiBags targets programs that use futures in a restricted fashion and runs in time $O(T_1 \alpha(m,n))$, where $T_1$ is the sequential running time of the program, $\alpha$ is the inverse Ackermann's function, $m$ is the total number of memory accesses, $n$ is the dynamic count of places at which parallelism is created. Since $\alpha$ is a very slowly growing function (upper bounded by $4$ for all practical purposes), it can be treated as a close-to-constant overhead. MultiBags+ an extension of MultiBags that target programs with general use of futures. It runs in time $O((T_1+k^2)\alpha(m,n))$ where $T_1$, $\alpha$, $m$ and $n$ are defined as before, and $k$ is the number of future operations in the computation. We implemented both algorithms and empirically demonstrate their efficiency

The Association of Thyrotropin and Autoimmune Thyroid Disease in Developing Papillary Thyroid Cancer

Background. Papillary thyroid carcinoma (PTC) is the most common type of malignant thyroid neoplasm. However, the incidence of PTC with autoimmune thyroid disease (AITD) varies between studies. This study aims to investigate whether patients with AITD have increased incidence of PTC. We also analyzed the relationship of serum thyroid-stimulating hormone (TSH) levels and PTC in relation to AITD based on histopathological data. Methods. A total of 533 participants who underwent thyroidectomy were enrolled in this retrospective study based on clinicohistopathological data and known thyroid autoantibodies. Patients were divided into PTC and benign groups according to histopathologic diagnosis. Age, gender, body mass index, and serum TSH level before thyroidectomy were recorded. Results. Of the 533 enrolled patients, 159 (29.8%) were diagnosed with PTC, of which 38 (35.5%) had Hashimoto’s thyroiditis (HT). More patients with HT were female, and patients with HT, Graves’ disease, and thyroid nodules with higher TSH level had a higher incidence of PTC. Conclusions. A high proportion of the patients with PTC had HT. There was a trend that a higher serum TSH level was associated with a greater risk of thyroid cancer

U(1)' solution to the mu-problem and the proton decay problem in supersymmetry without R-parity

The Minimal Supersymmetric Standard Model (MSSM) is plagued by two major fine-tuning problems: the mu-problem and the proton decay problem. We present a simultaneous solution to both problems within the framework of a U(1)'-extended MSSM (UMSSM), without requiring R-parity conservation. We identify several classes of phenomenologically viable models and provide specific examples of U(1)' charge assignments. Our models generically contain either lepton number violating or baryon number violating renormalizable interactions, whose coexistence is nevertheless automatically forbidden by the new U(1)' gauge symmetry. The U(1)' symmetry also prohibits the potentially dangerous and often ignored higher-dimensional proton decay operators such as QQQL and UUDE which are still allowed by R-parity. Thus, under minimal assumptions, we show that once the mu-problem is solved, the proton is sufficiently stable, even in the presence of a minimum set of exotics fields, as required for anomaly cancellation. Our models provide impetus for pursuing the collider phenomenology of R-parity violation within the UMSSM framework.Comment: Version published in Phys. Rev.

On-the-fly pipeline parallelism

Pipeline parallelism organizes a parallel program as a linear sequence of s stages. Each stage processes elements of a data stream, passing each processed data element to the next stage, and then taking on a new element before the subsequent stages have necessarily completed their processing. Pipeline parallelism is used especially in streaming applications that perform video, audio, and digital signal processing. Three out of 13 benchmarks in PARSEC, a popular software benchmark suite designed for shared-memory multiprocessors, can be expressed as pipeline parallelism. Whereas most concurrency platforms that support pipeline parallelism use a "construct-and-run" approach, this paper investigates "on-the-fly" pipeline parallelism, where the structure of the pipeline emerges as the program executes rather than being specified a priori. On-the-fly pipeline parallelism allows the number of stages to vary from iteration to iteration and dependencies to be data dependent. We propose simple linguistics for specifying on-the-fly pipeline parallelism and describe a provably efficient scheduling algorithm, the Piper algorithm, which integrates pipeline parallelism into a work-stealing scheduler, allowing pipeline and fork-join parallelism to be arbitrarily nested. The Piper algorithm automatically throttles the parallelism, precluding "runaway" pipelines. Given a pipeline computation with T[subscript 1] work and T[subscript ∞] span (critical-path length), Piper executes the computation on P processors in T[subscript P]≤ T[subscript 1]/P + O(T[subscript ∞] + lg P) expected time. Piper also limits stack space, ensuring that it does not grow unboundedly with running time. We have incorporated on-the-fly pipeline parallelism into a Cilk-based work-stealing runtime system. Our prototype Cilk-P implementation exploits optimizations such as lazy enabling and dependency folding. We have ported the three PARSEC benchmarks that exhibit pipeline parallelism to run on Cilk-P. One of these, x264, cannot readily be executed by systems that support only construct-and-run pipeline parallelism. Benchmark results indicate that Cilk-P has low serial overhead and good scalability. On x264, for example, Cilk-P exhibits a speedup of 13.87 over its respective serial counterpart when running on 16 processors.National Science Foundation (U.S.) (Grant CNS-1017058)National Science Foundation (U.S.) (Grant CCF-1162148)National Science Foundation (U.S.). Graduate Research Fellowshi

Memory abstractions for parallel programming

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2012.Cataloged from PDF version of thesis.Includes bibliographical references (p. 156-163).A memory abstraction is an abstraction layer between the program execution and the memory that provides a different "view" of a memory location depending on the execution context in which the memory access is made. Properly designed memory abstractions help ease the task of parallel programming by mitigating the complexity of synchronization or admitting more efficient use of resources. This dissertation describes five memory abstractions for parallel programming: (i) cactus stacks that interoperate with linear stacks, (ii) efficient reducers, (iii) reducer arrays, (iv) ownershipaware transactions, and (v) location-based memory fences. To demonstrate the utility of memory abstractions, my collaborators and I developed Cilk-M, a dynamically multithreaded concurrency platform which embodies the first three memory abstractions. Many dynamic multithreaded concurrency platforms incorporate cactus stacks to support multiple stack views for all the active children simultaneously. The use of cactus stacks, albeit essential, forces concurrency platforms to trade off between performance, memory consumption, and interoperability with serial code due to its incompatibility with linear stacks. This dissertation proposes a new strategy to build a cactus stack using thread-local memory mapping (or TLMM), which enables Cilk-M to satisfy all three criteria simultaneously. A reducer hyperobject allows different branches of a dynamic multithreaded program to maintain coordinated local views of the same nonlocal variable. With reducers, one can use nonlocal variables in a parallel computation without restructuring the code or introducing races. This dissertation introduces memory-mapped reducers, which admits a much more efficient access compared to existing implementations. When used in large quantity, reducers incur unnecessarily high overhead in execution time and space consumption. This dissertation describes support for reducer arrays, which offers the same functionality as an array of reducers with significantly less overhead. Transactional memory is a high-level synchronization mechanism, designed to be easier to use and more composable than fine-grain locking. This dissertation presents ownership-aware transactions, the first transactional memory design that provides provable safety guarantees for "opennested" transactions. On architectures that implement memory models weaker than sequential consistency, programs communicating via shared memory must employ memory-fences to ensure correct execution. This dissertation examines the concept of location-based memoryfences, which unlike traditional memory fences, incurs latency only when synchronization is necessary.by I-Ting Angelina Lee.Ph.D

Vitamin D level regulates serum lipids discrepantly in adults with and without dyslipidemia

Vitamin D deficiency is associated with hyperlipidemia, but it r emains unclear whether vitamin D supplementation reduces serum lipid levels. The aims of this study were to investigate the associations between increased serum 25-hydroxyvitamin D (25(OH)D) concentrations and lipid levels and identify the characteristics of people with or without lipid reduction associated with increased 25(OH)D levels. The medical records of 118 individuals (53 men; mean age, 54.4 ± 10.6 years) whose serum 25(OH)D levels increased between 2 consecutive measurements were retrospectively reviewed. People with increased 25(OH)D levels (from 22.7 (17.6–29.2) to 32.1 (25.6–36.8) mg/dL; P < 0.01) had a significant reduction in serum levels of triglycerides (TG s) (from 111.0 (80–164) to 104.5 (73–142) mg/dL; P < 0.01) and total cholesterol (TC) (from 187.5 (155–213) to 181.0 (150–210) mg/dL; P < 0.05). The individuals who responded to vitamin D (≥10% reduction in TG or TC levels) exhibited significantly higher baseline TG a nd TC levels than those who did not. Only patients with hyperlipidemia (not those without hyperlipidemia) at baseline exhibited significantly reduced TG and TC levels at fol low-up. However, increasing serum 25(OH)D concentrations were significantly correlated with decreasing lipid levels in individuals with baseline 25(OH)D levels less than 30 ng/mL and in individuals aged 50–65 years (not in patients younger than 50 years or older than 65 years). In conclusion, increasing serum 25(OH)D concentrations may be potentially helpful for the treatment of hyperlipidemia in people with vitamin D deficiency