bluuebunny/crossref_metadata_2025 huggingface dataset:
VZV encephalitis following successful treatment of CMV infection in a patient with kidney transplant
Authors: Nabi Shahzaib , Kahlon Pushpinderdeep , Goggins Mariella , Patel Anita
Published: December 2014

A 73-year-old woman with a history of deceased donor kidney transplantation and a recent cytomegalovirus (CMV) infection, presented to the emergency department with an altered mental status. She was found to have varicella zoster virus VZV encephalitis based on cerebrospinal fluid analysis and was treated successfully with intravenous valaciclovir with an improvement in her mental status. A review of the literature shows very few case reports on patients with kidney transplantation developing VZV encephalitis. A few case reports and studies report an association between CMV and VZV infection. In these patients, CMV infection can cause a marked decline in immunity and this predisposes them to other infections. Such associations have also been reported between other types of virus infections from the Herpesviridae family. The risk of disseminated VZV infection increases in the presence of CMV infection.
Langerhans cell histiocytosis presenting as hypothyroid goitre: a unique presentation
Authors: Marupudi Krishna Chaitanya , Karanth Suman S , Thomas Joseph
Published: December 2014

Langerhans cell histiocytosis (LCH) is a disease involving the antigen presenting cells, which can range from a single system involvement with an indolent course to a multisystem disease with increased morbidity. We present a rare case of LCH presenting as hypothyroid goitre that was successfully treated as per the LCH III trial protocol with a combination of vinblastine and oral prednisolone. We highlight the need for awareness of this rare presentation of LCH as a painless goitre which is often misdiagnosed as poorly differentiated thyroid carcinoma or overlooked as a benign disease.
Successful management of cutaneous pythiosis in a dog with subsequent cutaneous vasculitis
Authors: Mercer Jacqueline , White Amelia , Kennis Bob
Published: December 2014

A three‐year‐old, spayed female, Belgian Malinois from southwestern Alabama was presented to our referral hospital for a 75‐day history of progressively lichenified, mildly ulcerated lesions on the left front limb. Histopathology and fungal culture revealed Pythium insidiosum. The limb was amputated and the patient was treated with itraconazole 8.8 mg/kg oral once daily and terbinafine 33 mg/kg oral once daily. Cutaneous vasculitis occurred on day 28 of treatment, which may have constituted either a fixed drug eruption or an immune complex reaction to infection or immunotherapy. The skin lesions were mild and completely excised, so drugs were continued for three‐and‐a‐half months total with no other adverse reactions. At 12 months after presentation, the patient is currently disease‐free with no signs of pythiosis recurrence.
Window on a career with wildlife
Authors: Bridges Matt
Published: December 2014

A gap year spent working with primates in Africa and leatherback turtles in Grenada opened a window on an area of veterinary medicine not previously considered by Matt Bridges, a third‐year student at Nottingham university
Money matters for vet students
Authors: Beale Simon
Published: December 2014

Simon Beale, the money and welfare adviser at the Royal Veterinary College, discusses the cost of studying veterinary medicine, the grants and bursaries that are available, and the repayment of loans
Moving from practice to industry
Authors: Curtis Catriona
Published: December 2014

After working in mixed and then small animal practice, Catriona Curtis decided to switch to industry, joining Virbac Animal Health as a technical adviser
Ten‐minute chat
Authors: Grundy Martin
Published: December 2014

Following surgery on both shoulders, Martin Grundy had to move on from the Derbyshire practice in which he had worked happily for almost 30 years. However, he says, since being appointed as a claims consultant to the Veterinary Defence Society, he has never looked back.
Ten‐minute chat
Authors: Sprinz Joe
Published: December 2014

Joe Sprinz is a veterinarian in mixed practice. He joined BVA Council as the Royal Counties territorial representative and is now the elected representative for the South East on Council. He lives on a farm in Buckinghamshire with his wife, two rescue cats and a black labrador.
Studying veterinary medicine in Hungary
Authors: Lean Mel
Published: December 2014

Mel Lean is currently in her first year at Szent István University in Budapest, studying veterinary medicine as a mature student. Here, she describes how she ended up pursuing a veterinary degree in Hungary, and what getting there involved
Life as a UK vet student in Budapest
Authors: Lean Mel
Published: December 2014

In an article in Vet Record Careers last week, Mel Lean explained how she embarked on a veterinary degree at the Szent István university in Hungary. Here, she gives her first impressions of the city and the course
Caring for animals with cancer
Authors: Penzo Chiara
Published: December 2014

Chiara Penzo has been interested in oncology since her final‐year at vet school, and her career has been built upon it. Her job is as much about increasing awareness as treating cancer in pets, she says
Ten‐minute chat
Authors: Harwood David
Published: December 2014

David Harwood works in the Animal Health and Veterinary Laboratories Agency regional laboratory at Winchester. He also knows a lot about goats despite having never owned one.
Selling yourself: how to get a job in veterinary practice
Authors: Nell Adi
Published: December 2014

A CV is a sales document that should be designed to help you get a job interview, and not placed with the others that didn't catch the boss's eye, says Adi Nell, who heads up the SPVS CV reading service
Hirnantian strata identified in major intracratonic basins of central North America: implications for uppermost Ordovician stratigraphy
Authors: Demski Matthew W. , Wheadon Benjamin J. , Stewart Lori A. , Elias Robert J. , Young Graham A. , Nowlan Godfrey S. , Dobrzanski Edward P.
Published: December 2014

Carbon isotopes are analyzed for the first time from the Ordovician–Silurian boundary interval in the Williston and Hudson Bay basins of Manitoba, revealing a prominent positive excursion. The nature of this excursion and its co-occurrence with the appearance of the Ozarkodina hassi Conodont Zone and a distinctive coral-dominated macrofauna indicate that this is the upper portion (Metabolograptus persculptus Graptolite Zone) of the globally recognized Hirnantian isotopic carbon excursion (HICE). As a result, the Ordovician–Silurian boundary is placed at a higher position than previously thought, at the disconformable Stonewall – Fisher Branch formational boundary in the Williston Basin, and probably the Port Nelson – Severn River formational boundary in the Hudson Bay Basin. Disconformities within sections suggest periods of nondeposition due to subaerial exposure as sea level fluctuated during the Late Ordovician glaciation. Latest Ordovician (Hirnantian) deposition was far more widespread on the Laurentian craton than realized previously. Age determination and correlation having unprecedented precision are attainable within and between the Williston and Hudson Bay basins, and beyond.
Structural, dielectric, and multiferroic properties of (Bi0.5K0.5)(Fe0.5Nb0.5)O3
Authors: Dash Swagatika , Choudhary R.N.P. , Das Piyush R. , Kumar Ashok
Published: December 2014

A polycrystalline sample of (Bi0.5K0.5)(Fe0.5Nb0.5)O3 was prepared using a mixed oxide at 1000 °C. The preliminary structural analysis using X-ray diffraction data of the compound indicates the formation of a single-phase rhombohedral structure similar to that of parent BiFeO3. Microstructural and elemental analysis using a scanning electron micrograph and energy-dispersive X-ray spectroscopy, respectively, were carried out at room temperature with higher magnification exhibiting a uniform distribution of grains and stoichiometry. The appearance of hysteresis loops (P–E) confirms the existence of ferroelectricity of the sample with a high remnant polarization of (2Pr) 17.76 μCcm−2. Using impedance spectroscopy, the electrical properties of the material were investigated at a wide range of temperature (25–500 °C) and frequencies (1 kHz – 1 MHz) suggesting dielectric non-Debye-type relaxation in the material. The nature of the Nyquist plot ([Formula: see text] ∼ [Formula: see text]) shows the dominance of the grain contribution in the impedance. The bulk resistance of the compound decreases with increasing temperature, like that of a semiconductor, which shows a negative temperature coefficient of resistance (NTCR) behavior. The frequency dependence of AC conductivity suggests that that the material obeys Jonscher’s power law. Magnetic hysteresis (M–H) loop shows very weak ferromagnetic behavior at room temperature.
MicroRNA Sensor Based on Magnetic Beads and Enzymatic Probes
Authors: Zhang Yue , Zhou Dejian , He Junhui
Published: December 2014

MicroRNAs are associated with multiple cellular processes and diseases. Here, we designed a highly sensitive, magnetically retrievable biosensor using magnetic beads (MBs) as a model RNA sensor. The assay utilized two biotinylated probes, which were hybridized to the complementary target miRNA in a sandwich assay format. One of the biotinylated ends of the hybridization complex was immobilized onto the surface of a NeutrAvidin (NAV) coated MB and the other biotinylated end was conjugated to HRP via NAV-biotin interaction. The results were presented by colorimetric absorbance of the resorufin product from amplex red oxidation. We show that by combining the use of MBs as well as bio-specific immobilization, the sensitivity of miRNA detection is down to 100 pM. This model HRP-MBs system can be used for simple, rapid colorimetric quantification of low level DNA/RNA or other small molecules.
Study of the Ambient Vibration Energy Harvesting Based on Piezoelectric Effect
Authors: Si Hongyu , Dong Jinlu , Chen Lei , Sun Laizhi , Zhang Xiaodong , Gao Mintian
Published: December 2014

The resonance between piezoelectric vibrator and the vibration source is the key to maximize the ambient vibration energy harvesting by using piezoelectric generator. In this paper, the factors that influence the output power of a single piezoelectric vibrator are analyzed. The effect of geometry size (length, thickness, width of piezoelectric chip and thickness of metal shim) of a single cantilever piezoelectric vibrator to the output power is analyzed and simulated with the help of MATLAB (matrix laboratory). The curves that output power varies with geometry size are obtained when the displacement and load at the free end are constant. Then the paper points out multi-resonant frequency piezoelectric power generation, including cantilever multi-resonant frequency piezoelectric power generation and disc type multi-resonant frequency piezoelectric generation. Multi-resonant frequency of cantilever piezoelectric power generation can be realized by placing different quality mass at the free end, while disc type multi-resonant frequency piezoelectric generation can be realized through series and parallel connection of piezoelectric vibrator.
MP2 and DFT studies on interaction of a halide anion with the fully protonated form of 1,4,7-triazacyclononane
Authors: Gholiee Yasin , Salehzadeh Sadegh
Published: December 2014

Density functional theory (DFT) using PBE, PBE1PBE, B3P86, B97-1, and BHandHLYP functionals as well as MP2 calculations employing the TZVP basis set were used to study the formation of four host–guest complexes with formula [ H3L ⋯ X ]2+( X = F-, Cl-, Br-, and I-). The result of calculations on the structural parameters of [ H3L ⋯ Cl ]2+shows that the calculated data with BHandHLYP functional have the best agreement with the experimental data and all five DFT methods give the better result than MP2. The largest amounts of interaction energies between the halide anions and protonated macrocycle were also calculated by PBE functional. The results show the following trend for the formation of complexes in the gas phase: [ H3L ⋯ F ]2+> [ H3L ⋯ Cl ]2+> [ H3L ⋯ Br ]2+> [ H3L ⋯ I ]2+. Formation of the complexes in solution also shows the above trend where the [ H3L ⋯ Br ]2+and [ H3L ⋯ I ]2+complexes have positive [Formula: see text] values and probably cannot be formed.
Permanent proteins in the urine of healthy humans during the Mars-500 experiment
Authors: Larina Irina M. , Pastushkova Lyudmila Kh. , Tiys Evgeny S. , Kireev Kirill S. , Kononikhin Alexey S. , Starodubtseva Natalia L. , Popov Igor A. , Custaud Marc-Antoine , Dobrokhotov Igor V. , Nikolaev Evgeny N. , Kolchanov Nikolay A. , Ivanisenko Vladimir A.
Published: December 2014

Urinary proteins serve as indicators of various conditions in human normal physiology and disease pathology. Using mass spectrometry proteome analysis, the permanent constituent of the urine was examined in the Mars-500 experiment (520 days isolation of healthy volunteers in a terrestrial complex with an autonomous life support system). Seven permanent proteins with predominant distribution in the liver and blood plasma as well as extracellular localization were identified. Analysis of the overrepresentation of the molecular functions and biological processes based on Gene Ontology revealed that the functional association among these proteins was low. The results showed that the identified proteins may be independent markers of the various conditions and processes in healthy humans and that they can be used as standards in determination of the concentration of other proteins in the urine.
Preparation of lignite-based activated carbon with high specific capacitance for electrochemical capacitors
Authors: Xing Baolin , Cao Jianliang , Wang Yan , Yi Guiyun , Zhang Chuanxiang , Chen Lunjian , Huang Guangxu , Xu Bing
Published: December 2014

A lignite-based activated carbon (LAC) for electrochemical capacitors (ECs) was prepared from high moisture lignite by KOH activation, and the as-prepared sample was characterized by the N 2-sorption, scanning electron microscope (SEM), transmission electron microscope (TEM) and X-ray photoelectron spectroscopy (XPS) techniques. The electrochemical performances of ECs with activated carbon as electrodes in 3 M KOH aqueous solution were evaluated by constant current charge-discharge and cyclic voltammetry. The LAC exhibits a well-developed surface area of 2581 m2/g, a relative wide pore size distribution of 0.5–10 nm. The ECs with LAC as electrode materials presents a high specific capacitance of 392 F/g at a low current density of 50 mA/g, and still remains 315 F/g even at a high current density of 5 A/g. The residual specific capacitance is as high as 92.9% after 2000 cycles. Compared with the commercial activated carbon (Maxsorb: Commercial product, Kansai, Japan), the LAC based electrode materials shows superior capacitive performance in terms of specific capacitance and charge–discharge performance at the high current density.
Making the case for a "manufacturing execution system" for software development
Authors: Naedele Martin , Kazman Rick , Cai Yuanfang
Published: December 2014

Seeking to improve information integration throughout the manufacturing process.
Sensors for seniors
Authors: Kirkpatrick Keith
Published: December 2014

In-home technologies are helping seniors stay aware, healthy, and in touch.
The whole professional
Authors: Denning Peter J.
Published: December 2014

A new book inspires a reflection on what it means to be a whole, competent, and effective professional---and may portend a wave of disruption in education.
The responsive enterprise
Authors: Meijer Erik , Kapoor Vikram
Published: December 2014

Soon every company will be a software company.
On teaching *how to design programs*
Authors: Ramsey Norman
Published: December 2014

This paper presents a personal, qualitative case study of a first course using
How to Design Programs
and its functional teaching languages. The paper reconceptualizes the book's six-step design process as an eight-step design process ending in a new "review and refactor" step. It recommends specific approaches to students' difficulties with function descriptions, function templates, data examples, and other parts of the design process. It connects the process to interactive "world programs." It recounts significant, informative missteps in course design and delivery. Finally, it identifies some unsolved teaching problems and some potential solutions.
Folding domain-specific languages
Authors: Gibbons Jeremy , Wu Nicolas
Published: December 2014

A domain-specific language can be implemented by embedding within a general-purpose host language. This embedding may be
deep
or
shallow
, depending on whether terms in the language construct syntactic or semantic representations. The deep and shallow styles are closely related, and intimately connected to folds; in this paper, we explore that connection.
Pattern matching without K
Authors: Cockx Jesper , Devriese Dominique , Piessens Frank
Published: December 2014

Dependent pattern matching is an intuitive way to write programs and proofs in dependently typed languages. It is reminiscent of both pattern matching in functional languages and case analysis in on-paper mathematics. However, in general it is incompatible with new type theories such as homotopy type theory (HoTT). As a consequence, proofs in such theories are typically harder to write and to understand. The source of this incompatibility is the reliance of dependent pattern matching on the so-called K axiom - also known as the uniqueness of identity proofs - which is inadmissible in HoTT. The Agda language supports an experimental criterion to detect definitions by pattern matching that make use of the K axiom, but so far it lacked a formal correctness proof.

In this paper, we propose a new criterion for dependent pattern matching without K, and prove it correct by a translation to eliminators in the style of Goguen et al. (2006). Our criterion both allows more good definitions than existing proposals, and solves a previously undetected problem in the criterion offered by Agda. It has been implemented in Agda and is the first to be supported by a formal proof. Thus it brings the benefits of dependent pattern matching to contexts where we cannot assume K, such as HoTT. It also points the way to new forms of dependent pattern matching, for example on higher inductive types.
Compositional semantics for composable continuations
Authors: Downen Paul , Ariola Zena M.
Published: December 2014

Parigot's λμ-calculus, a system for computational reasoning about classical proofs, serves as a foundation for control operations embodied by operators like Scheme's callcc. We demonstrate that the call-by-value theory of the λμ-calculus contains a latent theory of delimited control, and that a known variant of λμ which unshackles the syntax yields a calculus of composable continuations from the existing constructs and rules for classical control. To relate to the various formulations of control effects, and to continuation-passing style, we use a form of compositional program transformations which preserves the underlying structure of equational theories, contexts, and substitution. Finally, we generalize the call-by-name and call-by-value theories of the λμ-calculus by giving a single parametric theory that encompasses both, allowing us to generate a call-by-need instance that defines a calculus of classical and delimited control with lazy evaluation and sharing.
Distilling abstract machines
Authors: Accattoli Beniamino , Barenbaum Pablo , Mazza Damiano
Published: December 2014

It is well-known that many environment-based abstract machines can be seen as strategies in lambda calculi with explicit substitutions (ES). Recently, graphical syntaxes and linear logic led to the linear substitution calculus (LSC), a new approach to ES that is halfway between small-step calculi and traditional calculi with ES. This paper studies the relationship between the LSC and environment-based abstract machines. While traditional calculi with ES simulate abstract machines, the LSC rather distills them: some transitions are simulated while others vanish, as they map to a notion of structural congruence. The distillation process unveils that abstract machines in fact implement weak linear head reduction, a notion of evaluation having a central role in the theory of linear logic. We show that such a pattern applies uniformly in call-by-name, call-by-value, and call-by-need, catching many machines in the literature. We start by distilling the KAM, the CEK, and a sketch of the ZINC, and then provide simplified versions of the SECD, the lazy KAM, and Sestoft's machine. Along the way we also introduce some new machines with global environments. Moreover, we show that distillation preserves the time complexity of the executions, i.e. the LSC is a complexity-preserving abstraction of abstract machines.
Type-based parametric analysis of program families
Authors: Chen Sheng , Erwig Martin
Published: December 2014

Previous research on static analysis for program families has focused on lifting analyses for single, plain programs to program families by employing idiosyncratic representations. The lifting effort typically involves a significant amount of work for proving the correctness of the lifted algorithm and demonstrating its scalability. In this paper, we propose a parameterized static analysis framework for program families that can automatically lift a class of type-based static analyses for plain programs to program families. The framework consists of a parametric logical specification and a parametric variational constraint solver. We prove that a lifted algorithm is correct provided that the underlying analysis algorithm is correct. An evaluation of our framework has revealed an error in a previous manually lifted analysis. Moreover, performance tests indicate that the overhead incurred by the general framework is bounded by a factor of 2.
Concurrent NetCore
Authors: Schlesinger Cole , Greenberg Michael , Walker David
Published: December 2014

In a Software-Defined Network (SDN), a central, computationally powerful
controller
manages a set of distributed, computationally simple
switches
. The controller computes a policy describing how each switch should route packets and
populates
packet-processing tables on each switch with rules to enact the routing policy. As network conditions change, the controller continues to add and remove rules from switches to adjust the policy as needed.

Recently, the SDN landscape has begun to change as several proposals for new, reconfigurable switching architectures, such as RMT [5] and FlexPipe [14] have emerged. These platforms provide switch programmers with many, flexible tables for storing packet-processing rules, and they offer programmers control over the packet fields that each table can analyze and act on. These reconfigurable switch architectures support a richer SDN model in which a switch
configuration
phase precedes the rule population phase [4]. In the configuration phase, the controller sends the switch a graph describing the layout and capabilities of the packet processing tables it will require during the population phase. Armed with this foreknowledge, the switch can allocate its hardware (or software) resources more efficiently.

We present a new, typed language, called Concurrent NetCore, for specifying routing policies
and
graphs of packet-processing tables. Concurrent NetCore includes features for specifying sequential, conditional and concurrent control-flow between packet-processing tables. We develop a fine-grained operational model for the language and prove this model coincides with a higher-level denotational model when programs are well-typed. We also prove several additional properties of well-typed programs, including strong normalization and determinism. To illustrate the utility of the language, we develop linguistic models of both the RMT and FlexPipe architectures and we give a multi-pass compilation algorithm that translates graphs and routing policies to the RMT model.
Refinement types for Haskell
Authors: Vazou Niki , Seidel Eric L. , Jhala Ranjit , Vytiniotis Dimitrios , Peyton-Jones Simon
Published: December 2014

SMT-based checking of refinement types for call-by-value languages is a well-studied subject. Unfortunately, the classical translation of refinement types to verification conditions is unsound under lazy evaluation. When checking an expression, such systems implicitly assume that all the free variables in the expression are bound to
values
. This property is trivially guaranteed by eager, but does not hold under lazy, evaluation. Thus, to be sound and precise, a refinement type system for Haskell and the corresponding verification conditions must take into account
which subset of
binders actually reduces to values. We present a stratified type system that labels binders as potentially diverging or not, and that (circularly) uses refinement types to verify the labeling. We have implemented our system in
L
IQUID
H
ASKELL and present an experimental evaluation of our approach on more than 10,000 lines of widely used Haskell libraries. We show that
L
IQUID
H
ASKELL is able to prove 96% of all recursive functions terminating, while requiring a modest 1.7 lines of termination-annotations per 100 lines of code.
Depending on types
Authors: Weirich Stephanie
Published: December 2014

Is Haskell a dependently typed programming language? Should it be? GHC's many type-system features, such as Generalized Algebraic Datatypes (GADTs), datatype promotion, multiparameter type classes, and type families, give programmers the ability to encode domain-specific invariants in their types. Clever Haskell programmers have used these features to enhance the reasoning capabilities of static type checking. But really, how far have we come? Could we do more?

In this talk, I will discuss dependently typed programming in Haskell, through examples, analysis and comparisons with modern full-spectrum dependently typed languages, such as Coq, Agda and Idris. What sorts of dependently typed programming can be done in Haskell now? What could GHC learn from these languages? Conversely, what lessons can GHC offer in return?
PREDATOR
Authors: Liu Tongping , Tian Chen , Hu Ziang , Berger Emery D.
Published: December 2014

False sharing is a notorious problem for multithreaded applications that can drastically degrade both performance and scalability. Existing approaches can precisely identify the sources of false sharing, but only report false sharing actually observed during execution; they do not generalize across executions. Because false sharing is extremely sensitive to object layout, these detectors can easily miss false sharing problems that can arise due to slight differences in memory allocation order or object placement decisions by the compiler. In addition, they cannot predict the impact of false sharing on hardware with different cache line sizes.

This paper presents PREDATOR, a predictive software-based false sharing detector. PREDATOR generalizes from a single execution to precisely predict false sharing that is latent in the current execution. PREDATOR tracks accesses within a range that could lead to false sharing given different object placement. It also tracks accesses within virtual cache lines, contiguous memory ranges that span actual hardware cache lines, to predict sharing on hardware platforms with larger cache line sizes. For each, it reports the exact program location of predicted false sharing problems, ranked by their projected impact on performance. We evaluate PREDATOR across a range of benchmarks and actual applications. PREDATOR identifies problems undetectable with previous tools, including two previously-unknown false sharing problems, with no false positives. PREDATOR is able to immediately locate false sharing problems in MySQL and the Boost library that had eluded detection for years.
Eliminating global interpreter locks in ruby through hardware transactional memory
Authors: Odaira Rei , Castanos Jose G. , Tomari Hisanobu
Published: December 2014

Many scripting languages use a Global Interpreter Lock (GIL) to simplify the internal designs of their interpreters, but this kind of lock severely lowers the multi-thread per-formance on multi-core machines. This paper presents our first results eliminating the GIL in Ruby using Hardware Transactional Memory (HTM) in the IBM zEnterprise EC12 and Intel 4th Generation Core processors. Though prior prototypes replaced a GIL with HTM, we tested real-istic programs, the Ruby NAS Parallel Benchmarks (NPB), the WEBrick HTTP server, and Ruby on Rails. We devised a new technique to dynamically adjust the transaction lengths on a per-bytecode basis, so that we can optimize the likelihood of transaction aborts against the relative overhead of the instructions to begin and end the transactions. Our results show that HTM achieved 1.9- to 4.4-fold speedups in the NPB programs over the GIL with 12 threads, and 1.6- and 1.2-fold speedups in WEBrick and Ruby on Rails, respectively. The dynamic transaction-length adjustment chose the best transaction lengths for any number of threads and applications with sufficiently long running times.
Efficient deterministic multithreading without global barriers
Authors: Lu Kai , Zhou Xu , Bergan Tom , Wang Xiaoping
Published: December 2014

Multithreaded programs execute nondeterministically on conventional architectures and operating systems. This complicates many tasks, including debugging and testing. Deterministic multithreading (DMT) makes the output of a multithreaded program depend on its inputs only, which can totally solve the above problem. However, current DMT implementations suffer from a common inefficiency: they use frequent global barriers to enforce a deterministic ordering on memory accesses. In this paper, we eliminate that inefficiency using an execution model we call deterministic lazy release consistency (DLRC). Our execution model uses the Kendo algorithm to enforce a deterministic ordering on synchronization, and it uses a deterministic version of the lazy release consistency memory model to propagate memory updates across threads. Our approach guarantees that programs execute deterministically even when they contain data races. We implemented a DMT system based on these ideas (RFDet) and evaluated it using 16 parallel applications. Our implementation targets C/C++ programs that use POSIX threads. Results show that RFDet gains nearly 2x speedup compared with DThreads-a start-of-the-art DMT system.
yaSpMV
Authors: Yan Shengen , Li Chao , Zhang Yunquan , Zhou Huiyang
Published: December 2014

SpMV is a key linear algebra algorithm and has been widely used in many important application domains. As a result, numerous attempts have been made to optimize SpMV on GPUs to leverage their massive computational throughput. Although the previous work has shown impressive progress, load imbalance and high memory bandwidth remain the critical performance bottlenecks for SpMV. In this paper, we present our novel solutions to these problems. First, we devise a new SpMV format, called blocked compressed common coordinate (BCCOO), which uses bit flags to store the row indices in a blocked common coordinate (COO) format so as to alleviate the bandwidth problem. We further improve this format by partitioning the matrix into vertical slices to enhance the cache hit rates when accessing the vector to be multiplied. Second, we revisit the segmented scan approach for SpMV to address the load imbalance problem. We propose a highly efficient matrix-based segmented sum/scan for SpMV and further improve it by eliminating global synchronization. Then, we introduce an auto-tuning framework to choose optimization parameters based on the characteristics of input sparse matrices and target hardware platforms. Our experimental results on GTX680 GPUs and GTX480 GPUs show that our proposed framework achieves significant performance improvement over the vendor tuned CUSPARSE V5.0 (up to 229% and 65% on average on GTX680 GPUs, up to 150% and 42% on average on GTX480 GPUs) and some most recently proposed schemes (e.g., up to 195% and 70% on average over clSpMV on GTX680 GPUs, up to 162% and 40% on average over clSpMV on GTX480 GPUs).
Well-structured futures and cache locality
Authors: Herlihy Maurice , Liu Zhiyu
Published: December 2014

In
fork-join parallelism
, a sequential program is split into a directed acyclic graph of tasks linked by directed dependency edges, and the tasks are executed, possibly in parallel, in an order consistent with their dependencies. A popular and effective way to extend fork-join parallelism is to allow threads to create
futures
. A thread creates a future to hold the results of a computation, which may or may not be executed in parallel. That result is returned when some thread
touches
that future, blocking if necessary until the result is ready. Recent research has shown that while futures can, of course, enhance parallelism in a structured way, they can have a deleterious effect on cache locality. In the worst case, futures can incur Ω(P T∞ + t T∞) deviations, which implies Ω(C P T∞ + C t T∞) additional cache misses, where C is the number of cache lines, P is the number of processors, t is the number of touches, and T∞ is the
computation span
. Since cache locality has a large impact on software performance on modern multicores, this result is troubling.

In this paper, however, we show that if futures are used in a simple, disciplined way, then the situation is much better: if each future is touched only once, either by the thread that created it, or by a later descendant of the thread that created it, then parallel executions with work stealing can incur at most O(C P T
2
∞) additional cache misses, a substantial improvement. This structured use of futures is characteristic of many (but not all) parallel applications.
Singe
Authors: Bauer Michael , Treichler Sean , Aiken Alex
Published: December 2014

We present Singe, a Domain Specific Language (DSL) compiler for combustion chemistry that leverages warp specialization to produce high performance code for GPUs. Instead of relying on traditional GPU programming models that emphasize data-parallel computations, warp specialization allows compilers like Singe to partition computations into sub-computations which are then assigned to different warps within a thread block. Fine-grain synchronization between warps is performed efficiently in hardware using producer-consumer named barriers. Partitioning computations using warp specialization allows Singe to deal efficiently with the irregularity in both data access patterns and computation. Furthermore, warp-specialized partitioning of computations allows Singe to fit extremely large working sets into on-chip memories. Finally, we describe the architecture and general compilation techniques necessary for constructing a warp-specializing compiler. We show that the warp-specialized code emitted by Singe is up to 3.75X faster than previously optimized data-parallel GPU kernels.
Time-warp
Authors: Diegues Nuno , Romano Paolo
Published: December 2014

The notion of permissiveness in Transactional Memory (TM) translates to only aborting a transaction when it cannot be accepted in any history that guarantees correctness criterion. This property is neglected by most TMs, which, in order to maximize implementation's efficiency, resort to aborting transactions under overly conservative conditions. In this paper we seek to identify a sweet spot between permissiveness and efficiency by introducing the Time-Warp Multi-version algorithm (TWM). TWM is based on the key idea of allowing an update transaction that has performed stale reads (i.e., missed the writes of concurrently committed transactions) to be serialized by committing it in the past, which we call a time-warp commit. At its core, TWM uses a novel, lightweight validation mechanism with little computational overheads. TWM also guarantees that read-only transactions can never be aborted. Further, TWM guarantees Virtual World Consistency, a safety property that is deemed as particularly relevant in the context of TM. We demonstrate the practicality of this approach through an extensive experimental study, where we compare TWM with four other TMs, and show an average performance improvement of 65% in high concurrency scenarios.
Trace driven dynamic deadlock detection and reproduction
Authors: Samak Malavika , Ramanathan Murali Krishna
Published: December 2014

Dynamic analysis techniques have been proposed to detect potential deadlocks. Analyzing and comprehending each potential deadlock to determine whether the deadlock is feasible in a real execution requires significant programmer effort. Moreover, empirical evidence shows that existing analyses are quite imprecise. This imprecision of the analyses further void the manual effort invested in reasoning about non-existent defects.

In this paper, we address the problems of imprecision of existing analyses and the subsequent manual effort necessary to reason about deadlocks. We propose a novel approach for deadlock detection by designing a dynamic analysis that intelligently leverages execution traces. To reduce the manual effort, we replay the program by making the execution follow a schedule derived based on the observed trace. For a real deadlock, its feasibility is automatically verified if the replay causes the execution to deadlock.

We have implemented our approach as part of WOLF and have analyzed many large (upto 160KLoC) Java programs. Our experimental results show that we are able to identify 74% of the reported defects as true (or false) positives automatically leaving very few defects for manual analysis. The overhead of our approach is negligible making it a compelling tool for practical adoption.
Triolet
Authors: Rodrigues Christopher , Jablin Thomas , Dakkak Abdul , Hwu Wen-Mei
Published: December 2014

Functional algorithmic skeletons promise a high-level programming interface for distributed-memory clusters that free developers from concerns of task decomposition, scheduling, and communication. Unfortunately, prior distributed functional skeleton frameworks do not deliver performance comparable to that achievable in a low-level distributed programming model such as C with MPI and OpenMP, even when used in concert with high-performance array libraries. There are several causes: they do not take advantage of shared memory on each cluster node; they impose a fixed partitioning strategy on input data; and they have limited ability to fuse loops involving skeletons that produce a variable number of outputs per input.

We address these shortcomings in the Triolet programming language through a modular library design that separates concerns of parallelism, loop nesting, and data partitioning. We show how Triolet substantially improves the parallel performance of algorithms involving array traversals and nested, variable-size loops over what is achievable in Eden, a distributed variant of Haskell. We further demonstrate how Triolet can substantially simplify parallel programming relative to C with MPI and OpenMP while achieving 23--100% of its performance on a 128-core cluster.
Portable, MPI-interoperable coarray fortran
Authors: Yang Chaoran , Bland Wesley , Mellor-Crummey John , Balaji Pavan
Published: December 2014

The past decade has seen the advent of a number of parallel programming models such as Coarray Fortran (CAF), Unified Parallel C, X10, and Chapel. Despite the productivity gains promised by these models, most parallel scientific applications still rely on MPI as their data movement model. One reason for this trend is that it is hard for users to incrementally adopt these new programming models in existing MPI applications. Because each model use its own runtime system, they duplicate resources and are potentially error-prone. Such independent runtime systems were deemed necessary because MPI was considered insufficient in the past to play this role for these languages.

The recently released MPI-3, however, adds several new capabilities that now provide all of the functionality needed to act as a runtime, including a much more comprehensive one-sided communication framework. In this paper, we investigate how MPI-3 can form a runtime system for one example programming model, CAF, with a broader goal of enabling a single application to use both MPI and CAF with the highest level of interoperability.
Lock contention aware thread migrations
Authors: Pusukuri Kishore Kumar , Gupta Rajiv , Bhuyan Laxmi Narayan
Published: December 2014

On a cache-coherent multicore multiprocessor system, the performance of a multithreaded application with high lock contention is very sensitive to the distribution of application threads across multiple processors. This is because the distribution of threads impacts the frequency of lock transfers between processors, which in turn impacts the frequency of last-level cache (LLC) misses that lie on the critical path of execution. Inappropriate distribution of threads across processors increases LLC misses in the critical path and significantly degrades performance of multithreaded programs. To alleviate the above problem, this paper overviews a thread migration technique, which migrates threads of a multithreaded program across multicore processors so that threads seeking locks are more likely to find the locks on the same processor.
Data structures for task-based priority scheduling
Authors: Wimmer Martin , Versaci Francesco , Träff Jesper Larsson , Cederman Daniel , Tsigas Philippas
Published: December 2014

We present three lock-free data structures for priority task scheduling: a priority work-stealing one, a centralized one with ρ-relaxed semantics, and a hybrid one combining both concepts. With the single-source shortest path (SSSP) problem as example, we show how the different approaches affect the prioritization and provide upper bounds on the number of examined nodes. We argue that priority task scheduling allows for an intuitive and easy way to parallelize the SSSP problem, notoriously a hard task. Experimental evidence supports the good scalability of the resulting algorithm. The larger aim of this work is to understand the trade-offs between scalability and priority guarantees in task scheduling systems. We show that ρ-relaxation is a valuable technique for improving the first, while still allowing semantic constraints to be satisfied: the lock-free, hybrid $k$-priority data structure can scale as well as work-stealing, while still providing strong priority scheduling guarantees, which depend on the parameter k. Our theoretical results open up possibilities for even more scalable data structures by adopting a weaker form of ρ-relaxation, which still enables the semantic constraints to be respected.
SCCMulti
Authors: Tomkins Daniel , Smith Timmie , Amato Nancy M. , Rauchwerger Lawrence
Published: December 2014

Tarjan's famous linear time, sequential algorithm for finding the strongly connected components (SCCs) of a graph relies on depth first search, which is inherently sequential. Deterministic parallel algorithms solve this problem in logarithmic time using matrix multiplication techniques, but matrix multiplication requires a large amount of total work. Randomized algorithms based on reachability -- the ability to get from one vertex to another along a directed path -- greatly improve the work bound in the average case. However, these algorithms do not always perform well; for instance, Divide-and-Conquer Strong Components (DCSC), a scalable, divide-and-conquer algorithm, has good expected theoretical limits, but can perform very poorly on graphs for which the maximum reachability of any vertex is small. A related algorithm, MultiPivot, gives very high probability guarantees on the total amount of work for all graphs, but this improvement introduces an overhead that increases the average running time. This work introduces SCCMulti, a multi-pivot improvement of DCSC that offers the same consistency as MultiPivot without the time overhead. We provide experimental results demonstrating SCCMulti's scalability; these results also show that SCCMulti is more consistent than DCSC and is always faster than MultiPivot.
Extracting logical structure and identifying stragglers in parallel execution traces
Authors: Isaacs Katherine E. , Gamblin Todd , Bhatele Abhinav , Bremer Peer-Timo , Schulz Martin , Hamann Bernd
Published: December 2014

We introduce a new approach to automatically extract an idealized
logical structure
from a parallel execution trace. We use this structure to define intuitive metrics such as the
lateness
of a process involved in a parallel execution. By analyzing and illustrating traces in terms of logical steps, we leverage a developer's understanding of the happened-before relations in a parallel program. This technique can uncover dependency chains, elucidate communication patterns, and highlight sources and propagation of delays, all of which may be obscured in a traditional trace visualization.
Beyond parallel programming with domain specific languages
Authors: Olukotun Kunle
Published: December 2014

Today, almost all computer architectures are parallel and heterogeneous; a combination of multiple CPUs, GPUs and specialized processors. This creates a challenging problem for application developers who want to develop high performance programs without the effort required to use low-level, architecture specific parallel programming models (e.g. OpenMP for CMPs, CUDA for GPUs, MPI for clusters). Domain-specific languages (DSLs) are a promising solution to this problem because they can provide an avenue for high-level application-specific abstractions with implicit parallelism to be mapped directly to low level architecture-specific programming models; providing both high programmer productivity and high execution performance.

In this talk I will describe an approach to building high performance DSLs, which is based on DSL embedding in a general purpose programming language, metaprogramming and a DSL infrastructure called Delite. I will describe how we transform DSL programs into efficient first-order low-level code using domain specific optimization, parallelism and locality optimization with parallel patterns, and architecture-specific code generation. All optimizations and transformations are implemented in Delite: an extensible DSL compiler infrastucture that significantly reduces the effort required to develop new DSLs. Delite DSLs for machine learning, data querying, graph analysis, and scientific computing all achieve performance competitive with manually parallelized C++ code.
21st century computer architecture
Authors: Hill Mark D.
Published: December 2014

This talk has two parts. The first part will discuss possible directions for computer architecture research, including architecture as infrastructure, energy first, impact of new technologies, and cross-layer opportunities. This part is based on a 2012 Computing Community Consortium (CCC) whitepaper effort led by Hill, as well as other recent National Academy and ISAT studies. See: http://cra.org/ccc/docs/init/21stcenturyarchitecturewhitepaper.pdf. The second part of the talk will discuss one or more exam-ples of cross-layer research advocated in the first part. For example, our analysis shows that many "big-memory" server workloads, such as databases, in-memory caches, and graph analytics, pay a high cost for page-based virtual memory: up to 50% of execution time wasted. Via small changes to the operating system (Linux) and hardware (x86-64 MMU), this work reduces execution time these workloads waste to less than 0.5%. The key idea is to map part of a process's linear virtual address space with a new incarnation of segmentation, while providing compatibility by mapping the rest of the virtual address space with pag-ing.