bluuebunny/crossref_metadata_2025 huggingface dataset:
Deep and profound hypothermia in haemorrhagic shock, friend or foe? A systematic review
Authors: Moffatt Samuel E , Mitchell S J B , Walke J L
Published: May 2017

Introduction

Survival in exsanguinating cardiac arrest patients is poor, as is neurological outcome in survivors. Hypothermia has traditionally been seen as harmful to trauma patients and associated with increased mortality; however, there has been speculation that cooling to very low temperatures (≤20°C) could be used to treat haemorrhagic trauma patients by the induction of a suspended animation period through extreme cooling, which improves survival and preserves neurological function. This has been termed emergency preservation and resuscitation (EPR).

Methods

A systematic review of the literature was used to examine the evidence base behind the use of deep and profound hypothermia in haemorrhagic shock (HS). It included original research articles (human or animal) with cooling to ≤20°C after HS or an experimental model replicating it. Normovolaemic cardiac arrest, central nervous system injury and non-HS models were excluded.

Results

Twenty articles using 456 animal subjects were included, in which 327 were cooled to ≤20°C. All studies describing good survival rates were possible using EPR and 19/20 demonstrated that EPR can preserve neurological function after prolonged periods of circulatory arrest or minimal circulatory flow. This additional period can be used for surgical intervention to arrest haemorrhage in HS that would otherwise be lethal.

Conclusions

The outcomes of this review have significant implications for application to human patients and the ongoing human clinical trial (EPR for Cardiac Arrest from Trauma). Current evidence suggests that hypothermia ≤20°C used in the form of EPR could be beneficial to the HS patient.
TiO2 used as photocatalyst for rhodamine B degradation under solar radiation
Authors: Ariyanti Dessy , Maillot Mathilde , Gao Wei
Published: May 2017

Transition metal oxide photocatalysis is a relatively new method representing advanced oxidation process to be applied in industrial wastewater treatment especially for degradation of organic pollutants. We investigate TiO2 as a photocatalyst for the photocatalytic degradation of Rhodamine B (RhB) under simulated sunlight. Various parameters and their effectiveness have been studied. The effects of processing parameters including catalyst loading and feed concentration were investigated; and the degradation pathway was proposed based on the UHPLC-MS analysis. The result showed that a higher kinetic rate can be obtained by employing low catalyst loading and feed concentration, i.e., 0.5 g/L of TiO2 loading and 5 ppm of RhB concentration, respectively. For this particular system, the optimum degradation rate ([Formula: see text]) can achieve 0.297/min. The effectiveness of solar light-TiO2 system for RhB degradation shows this method can be used for wastewater treatment.
A Supervised Incremental Learning Technique for Automatic Recognition of the Skeletal Maturity, or can a Machine Learn to Assess Bone Age Without Radiological Training from Experts?
Authors: Ayala-Raggi Salvador E. , Manzano Fernando Montoya , Barreto-Flores Aldrin , Sánchez-Urrieta Susana , Portillo-Robledo José Francisco , Bautista-López Verónica Edith , Ayala-Raggi Patricia
Published: May 2017

Skeletal maturity estimation is an important medical procedure in the early diagnosis of growth disorders. Traditionally, it is performed by an expert physician or radiologist who determines it based on a visual subjective inspection, the approximated bone age of the child. This task is time consuming and is usually dependent on the judgment of each particular physician. Therefore, automated methods are extremely valuable and desirable. In this paper, we propose and describe an automatic method to estimate skeletal maturity through a supervised and incremental learning approach. Our method determines bone age by comparing aligned images with a [Formula: see text]–[Formula: see text] regression classifier. Here, we have solved the difficult task of image alignment by designing a radiological-hand specific Active Appearance Model, which was developed from a varied set of hand-labeled radiological images. By using this active model, our system constructs its own learned database by increasing a set of shape-aligned training images which are incrementally stored. Thus, when a test image arrives at the system, the alignment process is performed before the classification task takes place. For that purpose, we designed an original layout of landmarks to be located in representative regions of the radiographical image of the hand. Our results show that it is possible to use pixels directly as classification features as long as training and testing images have been previously aligned in shape and pose.
Quantitative structure–activity relationships study of potent pyridinone scaffold derivatives as HIV-1 integrase inhibitors with therapeutic applications
Authors: Barzegar Abolfazl , Hamidi Hossein
Published: May 2017

Human immunodeficiency virus-1 (HIV-1) integrase appears to be a crucial target for developing new anti-HIV-1 therapeutic agents. Different quantitative structure–activity relationships (QSARs) algorithms have been used in order to develop efficient model(s) to predict the activity of new pyridinone derivatives against HIV-1 integrase. Multiple linear regression (MLR) and combined principal component analysis (PCA) with MLR have been applied to build QSAR models for a set of new pyridinone derivatives as potent anti-HIV-1 therapeutic agents. Four different approaches based on MLR method including; concrete-MLR, stepwise-MLR, concrete PCA–MLR and stepwise PCA–MLR were utilized for this aim. Twenty two different sets of descriptors containing 1613 descriptors were constructed for each optimized molecule. Comparison between predictability of the “concrete” and “stepwise” procedure in two different algorithms of MLR and PCA models indicated the advantage of the stepwise procedure over that of the simple concrete method. Although the PCA was employed for dimension reduction, using stepwise PCA–MLR model showed that the method has higher ability to predict the compounds’ activity. The stepwise PCA–MLR model showed highly validated statistical results both in fitting and prediction processes ([Formula: see text] and [Formula: see text]). Therefore, using stepwise PCA approach is suitable to remove ineffective descriptors, which results in remaining efficient descriptors for building good predictability stepwise PCA–MLR. The stepwise hybrid approach of PCA–MLR may be useful in derivation of highly predictive and interpretable QSAR models.
Structural and hidden properties of 1D point processes: A wavelet-based study
Authors: D’Ercole Roberto
Published: May 2017

A one-dimensional (1D) point process, if considered as a random measure, can be represented by a sum, at most countable, of Delta Dirac measures concentrated at some random points. The integration with respect to the point process leads to the definition of the continuous wavelet transform of the process itself. As a possible choice of the mother wavelet, we propose the Mexican hat and the Morlet wavelet in order to implement the energy density of the process as a function of two wavelet parameters. Such mathematical tool works as a microscope to process an in-depth analysis of some classes of processes, in particular homogeneous, cluster, and locally scaled processes.
Dirac-like operators on the Hilbert space of differential forms on manifolds with boundaries
Authors: Pérez-Pardo Juan Manuel
Published: May 2017

The problem of self-adjoint extensions of Dirac-type operators in manifolds with boundaries is analyzed. The boundaries might be regular or non-regular. The latter situation includes point-like interactions, also called delta-like potentials, in manifolds of dimension higher than one. Self-adjoint boundary conditions for the case of dimension 2 are obtained explicitly.
Complex geometry in the entanglement entropy of fermionic chains
Authors: Ares Filiberto , Esteve José G. , Falceto Fernando , Queiroz Amilcar R. De
Published: May 2017

The geometry of Riemann surfaces plays a relevant role in the study of entanglement entropy in the ground state of a free fermionic chain. Recently, a new symmetry for the entropy in non critical theories has been discovered. It is based on the Möbius transformations in a compact Riemann surface associated to the Hamiltonian of the system. Here, we argue how to extend it to critical theories supporting our conjectures with numerical tests. We also highlight the intriguing parallelism that exists with conformal symmetry in real space.
Comparative evaluations of the Monte Carlo-based light propagation simulation packages for optical imaging
Authors: Wang Lin , Ren Shenghan , Chen Xueli
Published: May 2017

Monte Carlo simulation of light propagation in turbid medium has been studied for years. A number of software packages have been developed to handle with such issue. However, it is hard to compare these simulation packages, especially for tissues with complex heterogeneous structures. Here, we first designed a group of mesh datasets generated by Iso2Mesh software, and used them to cross-validate the accuracy and to evaluate the performance of four Monte Carlo-based simulation packages, including Monte Carlo model of steady-state light transport in multi-layered tissues (MCML), tetrahedron-based inhomogeneous Monte Carlo optical simulator (TIMOS), Molecular Optical Simulation Environment (MOSE), and Mesh-based Monte Carlo (MMC). The performance of each package was evaluated based on the designed mesh datasets. The merits and demerits of each package were also discussed. Comparative results showed that the TIMOS package provided the best performance, which proved to be a reliable, efficient, and stable MC simulation package for users.
Tuning the electrical properties of polyaniline by copolymerization with o-bromoaniline
Authors: Waware Umesh S. , Hamouda A. M. S. , Hameed A. Shahul , Summers Gabriel J.
Published: May 2017

Polyaniline, poly(o-bromoaniline) and poly(aniline-co-o-bromoaniline)s have been prepared by chemical oxidative polymerization methods. A series of poly(aniline-co-o-bromoaniline) derivatives has been prepared by the chemical oxidative copolymerization of aniline with different mole ratio of o-bromoaniline by varying the feed ratios of the monomers with the introduction of o-bromoaniline units along the polymer backbone. The morphology of each poly(aniline-co-o-bromoaniline) derivative is observed as a porous network of aggregated nanoparticles with each nanoparticle having smaller nanoflake structures. Room temperature electrical conductivity studies reveal that polyaniline has a conductivity value of the order of 10[Formula: see text][Formula: see text]S/cm. However, the corresponding poly(aniline-co-o-bromoaniline), with 10% o-bromoaniline content, shows a fivefold increase of the electrical conductivity relative to the polyaniline homopolymer. The different polymer derivatives were characterized by 1H NMR spectrometry, Scanning electron microscopy (SEM) and Transmission electron microscopy (TEM) methods, AC conductivity and dielectric permittivity measurements.
Effect of Ruthenium Concentration on Structural and I-V Characteristics of ZnO Thin Films by Sol–Gel Method
Authors: Vettumperumal R. , Kalyanaraman S. , Thangavel R.
Published: May 2017

Nanocrystalline ruthenium (Ru)-doped ZnO thin films on sapphire substrate was prepared using sol–gel method by spin coating technique. The structural and I-V characteristics of Ru doped ZnO thin films were studied from the X-ray diffraction (XRD), X-ray photoelectron spectroscopy (XPS), scanning electron microscope (SEM) analysis and Raman spectroscopy. X-ray diffraction (XRD) results revealed that the deposited films belonged to hexagonal wurtzite structure with c-axis orientation. It is also confirmed from the Raman spectra. Enhancement of longitudinal optical (LO) phonon is observed by the strong electron–phonon interaction. An observed increment in sheet resistance with increase in dopant percentage of Ru (1–2[Formula: see text]mol%) in ZnO films was found and better I-V characteristic behavior was observed at 1[Formula: see text]mol% of Ru-doped ZnO thin films. Trap limited current flow inside the material was calculated from the log I versus log V plot in the higher voltage region.
Mapping shallow urban groundwater temperatures, a case study from Cardiff, UK
Authors: Farr G. J. , Patton A. M. , Boon D. P. , James D. R. , Williams B. , Schofield D. I.
Published: May 2017

Low-enthalpy ground source heating systems can help to reduce our dependence on fossil fuels, in turn reducing greenhouse gas emissions and increasing energy security. To de-risk and support the sustainable development, regulation and management of ground source heating systems in urban areas, detailed baseline mapping of groundwater temperatures is required. Groundwater temperatures were measured in 168 monitoring boreholes primarily within a Quaternary sand and gravel aquifer in the city of Cardiff, UK. The data have been used to create the first city-wide map of shallow groundwater temperatures in the UK. This map can be used both to support development of ground source heating and to act as a detailed baseline from which to measure change. Shallow groundwater temperatures under the city were found to be 2°C warmer than the UK average groundwater temperature and this additional heat is attributed to the urban heat island. The zone of seasonal fluctuation varies from 7.1 and 15.5 m below ground level (mbgl) within the shallow Quaternary aquifer, averaging 9.5 mbgl. Deeper groundwater temperature profiles incorporating both the Quaternary and bedrock aquifers suggest that a ‘zone of anthropogenic influence’ exists down to about 70 mbgl.
Big types in little runtime: open-world soundness and collaborative blame for gradual type systems
Authors: Vitousek Michael M. , Swords Cameron , Siek Jeremy G.
Published: May 2017

Gradual typing combines static and dynamic typing in the same language, offering programmers the error detection and strong guarantees of static types and the rapid prototyping and flexible programming idioms of dynamic types. Many gradually typed languages are implemented by translation into an untyped target language (e.g., Typed Clojure, TypeScript, Gradualtalk, and Reticulated Python). For such languages, it is desirable to support arbitrary interaction between translated code and legacy code in the untyped language while maintaining the type soundness of the translated code. In this paper we formalize this goal in the form of the open-world soundness criterion. We discuss why it is challenging to achieve open-world soundness using the traditional proxy-based approach for higher-order casts. However, the transient design satisfies open-world soundness. Indeed, we present a formal semantics for the transient design and prove that our semantics satisfies open-world soundness. In this paper we also solve a challenging problem for the transient design: how to provide blame tracking without proxies. We define a semantics for blame and prove the Blame Theorem. We also prove that the Gradual Guarantee holds for this system, ensuring that programs can be evolved freely between static and dynamic typing. Finally, we demonstrate that the runtime overhead of the transient approach is low in the context of Reticulated Python, an implementation of gradual typing for Python.
A promising semantics for relaxed-memory concurrency
Authors: Kang Jeehoon , Hur Chung-Kil , Lahav Ori , Vafeiadis Viktor , Dreyer Derek
Published: May 2017

Despite many years of research, it has proven very difficult to develop a memory model for concurrent programming languages that adequately balances the conflicting desiderata of programmers, compilers, and hardware. In this paper, we propose the first relaxed memory model that (1) accounts for a broad spectrum of features from the C++11 concurrency model, (2) is implementable, in the sense that it provably validates many standard compiler optimizations and reorderings, as well as standard compilation schemes to x86-TSO and Power, (3) justifies simple invariant-based reasoning, thus demonstrating the absence of bad "out-of-thin-air" behaviors, (4) supports "DRF" guarantees, ensuring that programmers who use sufficient synchronization need not understand the full complexities of relaxed-memory semantics, and (5) defines the semantics of racy programs without relying on undefined behaviors, which is a prerequisite for applicability to type-safe languages like Java.

The key novel idea behind our model is the notion of *promises*: a thread may promise to execute a write in the future, thus enabling other threads to read from that write out of order. Crucially, to prevent out-of-thin-air behaviors, a promise step requires a thread-local certification that it will be possible to execute the promised write even in the absence of the promise. To establish confidence in our model, we have formalized most of our key results in Coq.
Typed self-evaluation via intensional type functions
Authors: Brown Matt , Palsberg Jens
Published: May 2017

Many popular languages have a self-interpreter, that is, an interpreter for the language written in itself. So far, work on polymorphically-typed self-interpreters has concentrated on self-recognizers that merely recover a program from its representation. A larger and until now unsolved challenge is to implement a polymorphically-typed self-evaluator that evaluates the represented program and produces a representation of the result. We present F
ω

μ
i

, the first λ-calculus that supports a polymorphically-typed self-evaluator. Our calculus extends F
ω
with recursive types and intensional type functions and has decidable type checking. Our key innovation is a novel implementation of type equality proofs that enables us to define a versatile representation of programs. Our results establish a new category of languages that can support polymorphically-typed self-evaluators.
Interactive proofs in higher-order concurrent separation logic
Authors: Krebbers Robbert , Timany Amin , Birkedal Lars
Published: May 2017

When using a proof assistant to reason in an embedded logic -- like separation logic -- one cannot benefit from the proof contexts and basic tactics of the proof assistant. This results in proofs that are at a too low level of abstraction because they are cluttered with bookkeeping code related to manipulating the object logic.

In this paper, we introduce a so-called proof mode that extends the Coq proof assistant with (spatial and non-spatial) named proof contexts for the object logic. We show that thanks to these contexts we can implement high-level tactics for introduction and elimination of the connectives of the object logic, and thereby make reasoning in the embedded logic as seamless as reasoning in the meta logic of the proof assistant. We apply our method to Iris: a state of the art higher-order impredicative concurrent separation logic.

We show that our method is very general, and is not just limited to program verification. We demonstrate its generality by formalizing correctness proofs of fine-grained concurrent algorithms, derived constructs of the Iris logic, and a unary and binary logical relation for a language with concurrency, higher-order store, polymorphism, and recursive types. This is the first formalization of a binary logical relation for such an expressive language. We also show how to use the logical relation to prove contextual refinement of fine-grained concurrent algorithms.
Type soundness proofs with definitional interpreters
Authors: Amin Nada , Rompf Tiark
Published: May 2017

While type soundness proofs are taught in every graduate PL class, the gap between realistic languages and what is accessible to formal proofs is large. In the case of Scala, it has been shown that its formal model, the Dependent Object Types (DOT) calculus, cannot simultaneously support key metatheoretic properties such as environment narrowing and subtyping transitivity, which are usually required for a type soundness proof. Moreover, Scala and many other realistic languages lack a general substitution property.

The first contribution of this paper is to demonstrate how type soundness proofs for advanced, polymorphic, type systems can be carried out with an operational semantics based on high-level, definitional interpreters, implemented in Coq. We present the first mechanized soundness proofs in this style for System F and several extensions, including mutable references. Our proofs use only straightforward induction, which is significant, as the combination of big-step semantics, mutable references, and polymorphism is commonly believed to require coinductive proof techniques.

The second main contribution of this paper is to show how DOT-like calculi emerge from straightforward generalizations of the operational aspects of F, exposing a rich design space of calculi with path-dependent types inbetween System F and DOT, which we dub the System D Square.

By working directly on the target language, definitional interpreters can focus the design space and expose the invariants that actually matter at runtime. Looking at such runtime invariants is an exciting new avenue for type system design.
A relational model of types-and-effects in higher-order concurrent separation logic
Authors: Krogh-Jespersen Morten , Svendsen Kasper , Birkedal Lars
Published: May 2017

Recently we have seen a renewed interest in programming languages that tame the complexity of state and concurrency through refined type systems with more fine-grained control over effects. In addition to simplifying reasoning and eliminating whole classes of bugs, statically tracking effects opens the door to advanced compiler optimizations.

In this paper we present a relational model of a type-and-effect system for a higher-order, concurrent program- ming language. The model precisely captures the semantic invariants expressed by the effect annotations. We demonstrate that these invariants are strong enough to prove advanced program transformations, including automatic parallelization of expressions with suitably disjoint effects. The model also supports refinement proofs between abstract data types implementations with different internal data representations, including proofs that fine-grained concurrent algorithms refine their coarse-grained counterparts. This is the first model for such an expressive language that supports both effect-based optimizations and data abstraction.

The logical relation is defined in Iris, a state-of-the-art higher-order concurrent separation logic. This greatly simplifies proving well-definedness of the logical relation and also provides us with a powerful logic for reasoning in the model.
QWIRE: a core language for quantum circuits
Authors: Paykin Jennifer , Rand Robert , Zdancewic Steve
Published: May 2017

This paper introduces QWIRE (``choir''), a language for defining quantum circuits and an interface for manipulating them inside of an arbitrary classical host language. QWIRE is minimal---it contains only a few primitives---and sound with respect to the physical properties entailed by quantum mechanics. At the same time, QWIRE is expressive and highly modular due to its relationship with the host language, mirroring the QRAM model of computation that places a quantum computer (controlled by circuits) alongside a classical computer (controlled by the host language).

We present QWIRE along with its type system and operational semantics, which we prove is safe and strongly normalizing whenever the host language is. We give circuits a denotational semantics in terms of density matrices. Throughout, we investigate examples that demonstrate the expressive power of QWIRE, including extensions to the host language that (1) expose a general analysis framework for circuits, and (2) provide dependent types.
Serializability for eventual consistency: criterion, analysis, and applications
Authors: Brutschy Lucas , Dimitrov Dimitar , Müller Peter , Vechev Martin
Published: May 2017

Developing and reasoning about systems using eventually consistent data stores is a difficult challenge due to the presence of unexpected behaviors that do not occur under sequential consistency. A fundamental problem in this setting is to identify a correctness criterion that precisely captures intended application behaviors yet is generic enough to be applicable to a wide range of applications.

In this paper, we present such a criterion. More precisely, we generalize conflict serializability to the setting of eventual consistency. Our generalization is based on a novel dependency model that incorporates two powerful algebraic properties: commutativity and absorption. These properties enable precise reasoning about programs that employ high-level replicated data types, common in modern systems. To apply our criterion in practice, we also developed a dynamic analysis algorithm and a tool that checks whether a given program execution is serializable.

We performed a thorough experimental evaluation on two real-world use cases: debugging cloud-backed mobile applications and implementing clients of a popular eventually consistent key-value store. Our experimental results indicate that our criterion reveals harmful synchronization problems in applications, is more effective at finding them than prior approaches, and can be used for the development of practical, eventually consistent applications.
Coupling proofs are probabilistic product programs
Authors: Barthe Gilles , Grégoire Benjamin , Hsu Justin , Strub Pierre-Yves
Published: May 2017

Couplings are a powerful mathematical tool for reasoning about pairs of probabilistic processes. Recent developments in formal verification identify a close connection between couplings and pRHL, a relational program logic motivated by applications to provable security, enabling formal construction of couplings from the probability theory literature. However, existing work using pRHL merely shows existence of a coupling and does not give a way to prove quantitative properties about the coupling, needed to reason about mixing and convergence of probabilistic processes. Furthermore, pRHL is inherently incomplete, and is not able to capture some advanced forms of couplings such as shift couplings. We address both problems as follows.

First, we define an extension of pRHL, called x-pRHL, which explicitly constructs the coupling in a pRHL derivation in the form of a probabilistic product program that simulates two correlated runs of the original program. Existing verification tools for probabilistic programs can then be directly applied to the probabilistic product to prove quantitative properties of the coupling. Second, we equip x-pRHL with a new rule for while loops, where reasoning can freely mix synchronized and unsynchronized loop iterations. Our proof rule can capture examples of shift couplings, and the logic is relatively complete for deterministic programs.

We show soundness of x-PRHL and use it to analyze two classes of examples. First, we verify rapid mixing using different tools from coupling: standard coupling, shift coupling, and path coupling, a compositional principle for combining local couplings into a global coupling. Second, we verify (approximate) equivalence between a source and an optimized program for several instances of loop optimizations from the literature.
The influence of dependent types (keynote)
Authors: Weirich Stephanie
Published: May 2017

What has dependent type theory done for Haskell? In this talk, I will discuss the influence of dependent types on the design of programming languages and on the practice of functional programmers. Over the past ten years, the Glasgow Haskell compiler has adopted several type system features inspired by dependent type theory. However, this process has not been a direct translation; working in the context of an existing language has lead us to new designs in the semantics of dependent types. I will take a close look at what we have achieved in GHC and discuss what we have learned from this experiment: what works now, what doesn't work yet, and what has surprised us along the way.
Type safety analysis for Dart
Authors: Heinze Thomas S. , Møller Anders , Strocco Fabio
Published: May 2017

Optional typing is traditionally viewed as a compromise between static and dynamic type checking, where code without type annotations is not checked until runtime. We demonstrate that optional type annotations in Dart programs can be integrated into a flow analysis to provide static type safety guarantees both for annotated and non-annotated parts of the code. We explore two approaches: one that uses type annotations for filtering, and one that uses them as specifications. What makes this particularly challenging for Dart is that its type system is unsound even for fully annotated code. Experimental results show that the technique is remarkably effective, even without context sensitivity: 99.3% of all property lookup operations are reported type safe in a collection of benchmark programs.
A feature-based personalized recommender system for product-line configuration
Authors: Pereira Juliana Alves , Matuszyk Pawel , Krieter Sebastian , Spiliopoulou Myra , Saake Gunter
Published: May 2017

Today’s competitive marketplace requires the industry to understand unique and particular needs of their customers. Product line practices enable companies to create individual products for every customer by providing an interdependent set of features. Users configure personalized products by consecutively selecting desired features based on their individual needs. However, as most features are interdependent, users must understand the impact of their gradual selections in order to make valid decisions. Thus, especially when dealing with large feature models, specialized assistance is needed to guide the users in configuring their product. Recently, recommender systems have proved to be an appropriate mean to assist users in finding information and making decisions. In this paper, we propose an advanced feature recommender system that provides personalized recommendations to users. In detail, we offer four main contributions: (i) We provide a recommender system that suggests relevant features to ease the decision-making process. (ii) Based on this system, we provide visual support to users that guides them through the decision-making process and allows them to focus on valid and relevant parts of the configuration space. (iii) We provide an interactive open-source configurator tool encompassing all those features. (iv) In order to demonstrate the performance of our approach, we compare three different recommender algorithms in two real case studies derived from business experience.
A change-centric approach to compile configurable systems with #ifdefs
Authors: Braz Larissa , Gheyi Rohit , Mongiovi Melina , Ribeiro Márcio , Medeiros Flávio , Teixeira Leopoldo
Published: May 2017

Configurable systems typically use #ifdefs to denote variability. Generating and compiling all configurations may be time-consuming. An alternative consists of using variability-aware parsers, such as TypeChef. However, they may not scale. In practice, compiling the complete systems may be costly. Therefore, developers can use sampling strategies to compile only a subset of the configurations. We propose a change-centric approach to compile configurable systems with #ifdefs by analyzing only configurations impacted by a code change (transformation). We implement it in a tool called CHECKCONFIGMX, which reports the new compilation errors introduced by the transformation. We perform an empirical study to evaluate 3,913 transformations applied to the 14 largest files of BusyBox, Apache HTTPD, and Expat configurable systems. CHECKCONFIGMX finds 595 compilation errors of 20 types introduced by 41 developers in 214 commits (5.46% of the analyzed transformations). In our study, it reduces by at least 50% (an average of 99%) the effort of evaluating the analyzed transformations by comparing with the exhaustive approach without considering a feature model. CHECKCONFIGMX may help developers to reduce compilation effort to evaluate fine-grained transformations applied to configurable systems with #ifdefs.
Thermostat
Authors: Agarwal Neha , Wenisch Thomas F.
Published: May 2017

The advent of new memory technologies that are denser and cheaper than commodity DRAM has renewed interest in two-tiered main memory schemes. Infrequently accessed application data can be stored in such memories to achieve significant memory cost savings. Past research on two-tiered main memory has assumed a 4KB page size. However, 2MB huge pages are performance critical in cloud applications with large memory footprints, especially in virtualized cloud environments, where nested paging drastically increases the cost of 4KB page management. We present Thermostat, an application-transparent huge-page-aware mechanism to place pages in a dual-technology hybrid memory system while achieving both the cost advantages of two-tiered memory and performance advantages of transparent huge pages. We present an online page classification mechanism that accurately classifies both 4KB and 2MB pages as hot or cold while incurring no observable performance overhead across several representative cloud applications. We implement Thermostat in Linux kernel version 4.5 and evaluate its effectiveness on representative cloud computing workloads running under KVM virtualization. We emulate slow memory with performance characteristics approximating near-future high-density memory technology and show that Thermostat migrates up to 50% of application footprint to slow memory while limiting performance degradation to 3%, thereby reducing memory cost up to 30%.
GRIFFIN
Authors: Ge Xinyang , Cui Weidong , Jaeger Trent
Published: May 2017

Researchers are actively exploring techniques to enforce control-flow integrity (CFI), which restricts program execution to a predefined set of targets for each indirect control transfer to prevent code-reuse attacks. While hardware-assisted CFI enforcement may have the potential for advantages in performance and flexibility over software instrumentation, current hardware-assisted defenses are either incomplete (i.e., do not enforce all control transfers) or less efficient in comparison. We find that the recent introduction of hardware features to log complete control-flow traces, such as Intel Processor Trace (PT), provides an opportunity to explore how efficient and flexible a hardware-assisted CFI enforcement system may become. While Intel PT was designed to aid in offline debugging and failure diagnosis, we explore its effectiveness for online CFI enforcement over unmodified binaries by designing a parallelized method for enforcing various types of CFI policies. We have implemented a prototype called GRIFFIN in the Linux 4.2 kernel that enables complete CFI enforcement over a variety of software, including the Firefox browser and its jitted code. Our experiments show that GRIFFIN can enforce fine-grained CFI policies with shadow stack as recommended by researchers at a performance that is comparable to software-only instrumentation techniques. In addition, we find that alternative logging approaches yield significant performance improvements for trace processing, identifying opportunities for further hardware assistance.
Approximate Storage of Compressed and Encrypted Videos
Authors: Jevdjic Djordje , Strauss Karin , Ceze Luis , Malvar Henrique S.
Published: May 2017

The popularization of video capture devices has created strong storage demand for encoded videos. Approximate storage can ease this demand by enabling denser storage at the expense of occasional errors. Unfortunately, even minor storage errors, such as bit flips, can result in major visual damage in encoded videos. Similarly, video encryption, widely employed for privacy and digital rights management, may create long dependencies between bits that show little or no tolerance to storage errors.

In this paper we propose VideoApp, a novel and efficient methodology to compute bit-level reliability requirements for encoded videos by tracking visual and metadata dependencies within encoded bitstreams. We further show how VideoApp can be used to trade video quality for storage density in an optimal way. We integrate our methodology into a popular H.264 encoder to partition an encoded video stream into multiple streams that can receive different levels of error correction according to their reliability needs. When applied to a dense and highly error-prone multi-level cell storage substrate, our variable error correction mechanism reduces the error correction overhead by half under the most error-intolerant encoder settings, achieving quality/density points that neither compression nor approximation can achieve alone. Finally, we define the basic invariants needed to support encrypted approximate video storage. We present an analysis of block cipher modes of operation, showing that some are fully compatible with approximation, enabling approximate and secure video storage systems.
An Architecture Supporting Formal and Compositional Binary Analysis
Authors: McMahan Joseph , Christensen Michael , Nichols Lawton , Roesch Jared , Guo Sung-Yee , Hardekopf Ben , Sherwood Timothy
Published: May 2017

Building a trustworthy life-critical embedded system requires deep reasoning about the potential effects that sequences of machine instructions can have on full system operation. Rather than trying to analyze complete binaries and the countless ways their instructions can interact with one another --- memory, side effects, control registers, implicit state, etc. --- we explore a new approach. We propose an architecture controlled by a thin computational layer designed to tightly correspond with the lambda calculus, drawing on principles of functional programming to bring the assembly much closer to myriad reasoning frameworks, such as the Coq proof assistant. This approach allows assembly-level verified versions of critical code to operate safely in tandem with arbitrary code, including imperative and unverified system components, without the need for large supporting trusted computing bases. We demonstrate that this computational layer can be built in such a way as to simultaneously provide full programmability and compact, precise, and complete semantics, while still using hardware resources comparable to normal embedded systems. To demonstrate the practicality of this approach, our FPGA-implemented prototype runs an embedded medical application which monitors and treats life-threatening arrhythmias. Though the system integrates untrusted and imperative components, our architecture allows for the formal verification of multiple properties of the end-to-end system, including a proof of correctness of the assembly-level implementation of the core algorithm, the integrity of trusted data via a non-interference proof, and a guarantee that our prototype meets critical timing requirements.
Breaking the Boundaries in Heterogeneous-ISA Datacenters
Authors: Barbalace Antonio , Lyerly Robert , Jelesnianski Christopher , Carno Anthony , Chuang Ho-Ren , Legout Vincent , Ravindran Binoy
Published: May 2017

Energy efficiency is one of the most important design considerations in running modern datacenters. Datacenter operating systems rely on software techniques such as execution migration to achieve energy efficiency across pools of machines. Execution migration is possible in datacenters today because they consist mainly of homogeneous-ISA machines. However, recent market trends indicate that alternate ISAs such as ARM and PowerPC are pushing into the datacenter, meaning current execution migration techniques are no longer applicable. How can execution migration be applied in future heterogeneous-ISA datacenters?

In this work we present a compiler, runtime, and an operating system extension for enabling execution migration between heterogeneous-ISA servers. We present a new multi-ISA binary architecture and heterogeneous-OS containers for facilitating efficient migration of natively-compiled applications. We build and evaluate a prototype of our design and demonstrate energy savings of up to 66% for a workload running on an ARM and an x86 server interconnected by a high-speed network.
What Scalable Programs Need from Transactional Memory
Authors: Nguyen Donald , Pingali Keshav
Published: May 2017

Transactional memory (TM) has been the focus of numerous studies, and it is supported in processors such as the IBM Blue Gene/Q and Intel Haswell. Many studies have used the STAMP benchmark suite to evaluate their designs. However, the speedups obtained for the STAMP benchmarks on all TM systems we know of are quite limited; for example, with 64 threads on the IBM Blue Gene/Q, we observe a median speedup of 1.4X using the Blue Gene/Q hardware transactional memory (HTM), and a median speedup of 4.1X using a software transactional memory (STM).

What limits the performance of these benchmarks on TMs? In this paper, we argue that the problem lies with the programming model and data structures used to write them. To make this point, we articulate two principles that we believe must be embodied in any scalable program and argue that STAMP programs violate both of them. By modifying the STAMP programs to satisfy both principles, we produce a new set of programs that we call the Stampede suite. Its median speedup on the Blue Gene/Q is 8.0X when using an STM. The two principles also permit us to simplify the TM design. Using this new STM with the Stampede benchmarks, we obtain a median speedup of 17.7X with 64 threads on the Blue Gene/Q and 13.2X with 32 threads on an Intel Westmere system.

These results suggest that HTM and STM designs will benefit if more attention is paid to the division of labor between application programs, systems software, and hardware.
Towards Practical Default-On Multi-Core Record/Replay
Authors: Mashtizadeh Ali José , Garfinkel Tal , Terei David , Mazieres David , Rosenblum Mendel
Published: May 2017

We present Castor, a record/replay system for multi-core applications that provides consistently low and predictable overheads. With Castor, developers can leave record and replay on by default, making it practical to record and reproduce production bugs, or employ fault tolerance to recover from hardware failures.

Castor is inspired by several observations: First, an efficient mechanism for logging non-deterministic events is critical for recording demanding workloads with low overhead. Through careful use of hardware we were able to increase log throughput by 10x or more, e.g., we could record a server handling 10x more requests per second for the same record overhead. Second, most applications can be recorded without modifying source code by using the compiler to instrument language level sources of non-determinism, in conjunction with more familiar techniques like shared library interposition. Third, while Castor cannot deterministically replay all data races, this limitation is generally unimportant in practice, contrary to what prior work has assumed.

Castor currently supports applications written in C, C++, and Go on FreeBSD. We have evaluated Castor on parallel and server workloads, including a commercial implementation of memcached in Go, which runs Castor in production.
Locality Transformations for Nested Recursive Iteration Spaces
Authors: Sundararajah Kirshanthan , Sakka Laith , Kulkarni Milind
Published: May 2017

There has been a significant amount of effort invested in designing scheduling transformations such as loop tiling and loop fusion that rearrange the execution of dynamic instances of loop nests to place operations that access the same data close together temporally. In recent years, there has been interest in designing similar transformations that operate on recursive programs, but until now these transformations have only considered simple scenarios: multiple recursions to be fused, or a recursion nested inside a simple loop. This paper develops the first set of scheduling transformations for nested recursions: recursive methods that call other recursive methods. These are the recursive analog to nested loops. We present a transformation called recursion twisting that automatically improves locality at all levels of the memory hierarchy, and show that this transformation can yield substantial performance improvements across several benchmarks that exhibit nested recursion.
Exploiting Intra-Request Slack to Improve SSD Performance
Authors: Elyasi Nima , Arjomand Mohammad , Sivasubramaniam Anand , Kandemir Mahmut T. , Das Chita R. , Jung Myoungsoo
Published: May 2017

With Solid State Disks (SSDs) offering high degrees of parallelism, SSD controllers place data and direct requests to exploit the maximum offered hardware parallelism. In the quest to maximize parallelism and utilization, sub-requests of a request that are directed to different flash chips by the scheduler can experience differential wait times since their individual queues are not coordinated and load balanced at all times. Since the macro request is considered complete only when its last sub-request completes, some of its sub-requests that complete earlier have to necessarily wait for this last sub-request. This paper opens the door to a new class of schedulers to leverage such
slack
between sub-requests in order to improve response times. Specifically, the paper presents the design and implementation of a slack-enabled re-ordering scheduler, called
Slacker
, for sub-requests issued to each flash chip. Layered under a modern SSD request scheduler, Slacker estimates the slack of each incoming sub-request to a flash chip and allows them to jump ahead of existing sub-requests with sufficient slack so as to not detrimentally impact their response times. Slacker is simple to implement and imposes only marginal additions to the hardware. Using a spectrum of 21 workloads with diverse read-write characteristics, we show that Slacker provides as much as 19.5%, 13% and 14.5% improvement in response times, with average improvements of 12%, 6.5% and 8.5%, for write-intensive, read-intensive and read-write balanced workloads, respectively.
IncBricks
Authors: Liu Ming , Luo Liang , Nelson Jacob , Ceze Luis , Krishnamurthy Arvind , Atreya Kishore
Published: May 2017

The emergence of programmable network devices and the increasing data traffic of datacenters motivate the idea of in-network computation. By offloading compute operations onto intermediate networking devices (e.g., switches, network accelerators, middleboxes), one can (1) serve network requests on the fly with low latency; (2) reduce datacenter traffic and mitigate network congestion; and (3) save energy by running servers in a low-power mode. However, since (1) existing switch technology doesn't provide general computing capabilities, and (2) commodity datacenter networks are complex (e.g., hierarchical fat-tree topologies, multipath communication), enabling in-network computation inside a datacenter is challenging.

In this paper, as a step towards in-network computing, we present IncBricks, an in-network caching fabric with basic computing primitives. IncBricks is a hardware-software co-designed system that supports caching in the network using a programmable network middlebox. As a key-value store accelerator, our prototype lowers request latency by over 30% and doubles throughput for 1024 byte values in a common cluster configuration. Our results demonstrate the effectiveness of in-network computing and that efficient datacenter network request processing is possible if we carefully split the computation across the different programmable computing elements in a datacenter, including programmable switches, network accelerators, and end hosts.