bluuebunny/crossref_metadata_2025 huggingface dataset:
Process evaluations in neurological rehabilitation: a mixed-evidence systematic review and recommendations for future research
Authors: Masterson-Algar Patricia , Burton Christopher R , Rycroft-Malone Jo
Published: November 2016

Objective

To systematically review how process evaluations are currently designed, what methodologies are used and how are they developed alongside or within neurological rehabilitation trials.

Methods

This mixed-methods systematic review had two evidence streams: stream I, studies reporting process evaluations alongside neurorehabilitation trials research and stream II, methodological guidance on process evaluation design and methodology. A search strategy was designed for each evidence stream. Data regarding process evaluation core concepts and design issues were extracted using a bespoke template. Evidence from both streams was analysed separately and then synthesised in a final overarching synthesis proposing a number of recommendations for future research.

Results

A total of 124 process evaluation studies, reporting on 106 interventions, were included in stream I evidence. 30 studies were included as stream II evidence. Synthesis 1 produced 9 themes, and synthesis 2 identified a total of 8 recommendations for process evaluation research. The overall synthesis resulted in 57 ‘synthesis recommendations’ about process evaluation methodology grouped into 9 research areas, including the use of theory, the investigation of context, intervention staff characteristics and the delivery of the trial intervention.

Conclusions

There remains no consensus regarding process evaluation terminology within the neurological rehabilitation field. There is a need for process evaluations to address the nature and influence of context over time. Process evaluations should clearly describe what intervention staff bring to a trial, including skills and experience prior to joining the research. Process evaluations should monitor intervention staff's learning effects and the possible impact that these may have on trial outcomes.
Comparison of immunohematological profile between endurance- and power-oriented elite athletes
Authors: Morgado José P. , Matias Catarina N. , Monteiro Cristina P. , Alves Francisco , Reis Joana F. , Santos Diana A. , Silva Analiza M. , Martins Fátima , Seixas Maria T. , Rocha-Pereira Petronila , Sardinha Luís B. , Laires Maria J.
Published: November 2016

There is general perception that elite athletes are highly susceptible to changes in immunohematological profile. The objective of this study was to compare immunohematological parameters of elite athletes of different aerobic and muscular strength sports and analyze changes over 2 months. Sixteen judoists and 14 swimmers were evaluated 2 months before (M1) and immediately prior to competition (M2). Hemogram and lymphocytes subpopulations were assessed with automatic counter and flow cytometry, respectively. Judoists had higher neutrophils and lower monocytes and eosinophils percentages than swimmers at M1 and M2. At M2 judoists had lower red blood cells (RBC), hemoglobin, and hematocrit than swimmers. At M2 judoists’ hematocrit and CD16 decreased while swimmers’ hemoglobin and hematocrit increased. In conclusion, neither sports characteristics nor intense training seem to displace the athletes’ immunohematological profile out of the clinical range, despite the possibility of occurrence of microlesions that may stimulate production of leukocytes and reduction of RBC in judoists.
Poisson equation for the three-loop ladder diagram in string theory at genus one
Authors: Basu Anirban
Published: November 2016

The three-loop ladder diagram is a graph with six links and four cubic vertices that contributes to the [Formula: see text] amplitude at genus one in type II string theory. The vertices represent the insertion points of vertex operators on the toroidal worldsheet and the links represent scalar Green functions connecting them. By using the properties of the Green function and manipulating the various expressions, we obtain a modular invariant Poisson equation satisfied by this diagram, with source terms involving one-, two- and three-loop diagrams. Unlike the source terms in the Poisson equations for diagrams at lower orders in the momentum expansion or the Mercedes diagram, a particular source term involves a five-point function containing a holomorphic and a antiholomorphic worldsheet derivative acting on different Green functions. We also obtain simple equalities between topologically distinct diagrams, and consider some elementary examples.
Thermal effects of a photon gas with a deformed Heisenberg algebra
Authors: Bufalo R.
Published: November 2016

In this paper, we have considered the thermodynamics of a photon gas subject to the presence of a minimal measurable length following from a covariant extension of the original generalized uncertainty principle (GUP). After consistently establishing a generalized dynamics, we define a GUP deformed Maxwell invariant which serves as the basis for our study. In order to highlight the GUP effects, we compute the one- and two-loop order contribution to the partition function at the high-temperature limit. Afterwards, by computing the internal energy density, we conclude that the additional terms can be seen as corrections [Formula: see text] to the Stefan–Boltzmann law due to GUP effects.
Cooper pairs and bipolarons
Authors: Lakhno Victor
Published: November 2016

It is shown that Cooper pairs are a solution of the bipolaron problem for model Fröhlich Hamiltonian. The total energy of a pair for the initial Fröhlich Hamiltonian is found. Differences between the solutions for the model and initial two-particle problems are discussed.
Boundary-layer analysis of a pile-up of walls of edge dislocations at a lock
Authors: Garroni Adriana , van Meurs Patrick , Peletier Mark A. , Scardia Lucia
Published: November 2016

In this paper, we analyse the behaviour of a pile-up of vertically periodic walls of edge dislocations at an obstacle, represented by a locked dislocation wall. Starting from a continuum nonlocal energy [Formula: see text] modelling the interactions — at a typical length-scale of [Formula: see text] — of the walls subjected to a constant shear stress, we derive a first-order approximation of the energy [Formula: see text] in powers of [Formula: see text] by [Formula: see text]-convergence, in the limit [Formula: see text]. While the zeroth-order term in the expansion, the [Formula: see text]-limit of [Formula: see text], captures the “bulk” profile of the density of dislocation walls in the pile-up domain, the first-order term in the expansion is a “boundary-layer” energy that captures the profile of the density in the proximity of the lock. This study is a first step towards a rigorous understanding of the behaviour of dislocations at obstacles, defects, and grain boundaries.
Gravitational wave detection in space
Authors: Ni Wei-Tou
Published: November 2016

Gravitational Wave (GW) detection in space is aimed at low frequency band (100[Formula: see text]nHz–100[Formula: see text]mHz) and middle frequency band (100[Formula: see text]mHz–10[Formula: see text]Hz). The science goals are the detection of GWs from (i) Supermassive Black Holes; (ii) Extreme-Mass-Ratio Black Hole Inspirals; (iii) Intermediate-Mass Black Holes; (iv) Galactic Compact Binaries and (v) Relic GW Background. In this paper, we present an overview on the sensitivity, orbit design, basic orbit configuration, angular resolution, orbit optimization, deployment, time-delay interferometry (TDI) and payload concept of the current proposed GW detectors in space under study. The detector proposals under study have arm length ranging from 1000[Formula: see text]km to [Formula: see text][Formula: see text]km (8.6[Formula: see text]AU) including (a) Solar orbiting detectors — (ASTROD Astrodynamical Space Test of Relativity using Optical Devices (ASTROD-GW) optimized for GW detection), Big Bang Observer (BBO), DECi-hertz Interferometer GW Observatory (DECIGO), evolved LISA (e-LISA), Laser Interferometer Space Antenna (LISA), other LISA-type detectors such as ALIA, TAIJI etc. (in Earthlike solar orbits), and Super-ASTROD (in Jupiterlike solar orbits); and (b) Earth orbiting detectors — ASTROD-EM/LAGRANGE, GADFLI/GEOGRAWI/g-LISA, OMEGA and TIANQIN.
COMPLEX PATTERNS IN FINANCIAL TIME SERIES THROUGH HIGUCHI’S FRACTAL DIMENSION
Authors: GRACE ELIZABETH RANI T. G. , JAYALALITHA G.
Published: November 2016

This paper analyzes the complexity of stock exchanges through fractal theory. Closing price indices of four stock exchanges with different industry sectors are selected. Degree of complexity is assessed through Higuchi’s fractal dimension. Various window sizes are considered in evaluating the fractal dimension. It is inferred that the data considered as a whole represents random walk for all the four indices. Analysis of financial data through windowing procedure exhibits multi-fractality. Attempts to apply moving averages to reduce noise in the data revealed lower estimates of fractal dimension, which was verified using fractional Brownian motion. A change in the normalization factor in Higuchi’s algorithm did improve the results. It is quintessential to focus on rural development to realize a standard and steady growth of economy. Tools must be devised to settle the issues in this regard. Micro level institutions are necessary for the economic growth of a country like India, which would induce a sporadic development in the present global economical scenario.
PERFORMANCE ANALYSIS OF COPPER TIN SULFIDE, Cu2SnS3 (CTS) WITH VARIOUS BUFFER LAYERS BY USING SCAPS IN SOLAR CELLS
Authors: AMIRI I. S. , AHMAD H. , ARIANNEJAD M. M. , ISMAIL M. F. , THAMBIRATNAM K. , YASIN M. , NIK ABDUL-AZIZ N. M. A.
Published: November 2016

This work examines the performance of the Cu2SnS3 (CTS) solar cells using the solar cell capacitance simulator (SCAPS) approach. The performance of the CTS solar cell was evaluated in terms of [Formula: see text], [Formula: see text], fill factor and efficiency. The structural parameter variation of CTS solar cell has been studied in terms of buffer and absorber layer thickness, bandgap, effect of temperature on total efficiency of the solar cell. Increasing the thickness of the CdS buffer layer decreases the efficiency of the simulated solar cell. A significant increase in the efficiency of the solar cell to 20.36% was obtained with a simulated buffer layer thickness to 10[Formula: see text]nm. In terms of the CTS absorber layer thickness, the efficiency of the solar cell increases by increasing the thickness of absorber layer. By setting the thickness of CTS to 4.0[Formula: see text][Formula: see text]m, the efficiency obtained is 20.36%. It is observed that an increase in the bandgap can enhance the efficiency of the solar cell. In the performed simulation, an 0.9[Formula: see text]eV bandgap resulted in a 11.58% cell efficiency and a 1.25[Formula: see text]eV bandgap resulted in 21.96% cell efficiency. In terms of temperature, the efficiency of 20.36% was obtained at 300[Formula: see text]K, and as the temperature increases, cell efficiency will decrease.
Infinite products with coefficients which vanish on certain arithmetic progressions
Authors: Alaca Ayşe , Alaca Şaban , Aygin Zafer Selcuk , Williams Kenneth S.
Published: November 2016

Let [Formula: see text] denote a complex variable with [Formula: see text]. For a positive integer [Formula: see text] let [Formula: see text] If [Formula: see text] we define [Formula: see text] for each nonnegative integer [Formula: see text]. In this paper, we determine results of the type [Formula: see text]
Toward an explicit eigencurve for GL(3)
Authors: Ash Avner , Pollack David
Published: November 2016

Starting with a numerically noncritical (at [Formula: see text]) Hecke eigenclass [Formula: see text] in the homology of a congruence subgroup [Formula: see text] of [Formula: see text] (where [Formula: see text] divides the level of [Formula: see text]) with classical coefficients, we first show how to compute to any desired degree of accuracy a lift of [Formula: see text] to a Hecke eigenclass [Formula: see text] with coefficients in a module of [Formula: see text]-adic distributions. Then we show how to find to any desired degree of accuracy the germ of the projection [Formula: see text] to weight space of the eigencurve around the point [Formula: see text] corresponding to the system of Hecke eigenvalues of [Formula: see text]. We do this under the conjecturally mild hypothesis that [Formula: see text] is smooth at [Formula: see text].
The shifted sum of the first n values of Euler’s function
Authors: Gong Ming-Liang , Chen Yong-Gao
Published: November 2016

In this paper, we prove that, for any given odd number [Formula: see text], the number of integers [Formula: see text] such that [Formula: see text] is a square is [Formula: see text], where [Formula: see text] is the Euler totient function. Beyond this, we pose a conjecture and a problem for further research.
An integer-valued expression of Dedekind sums
Authors: Macourt Simon
Published: November 2016

We prove a conjecture of Myerson and Phillips on when an expression involving Dedekind sums is an integer. We also provide a more general result and use this to extend the work of Myerson and Phillips studying whether the points of the graph of the one-variable Dedekind sum that fall on the line are dense.
The Frobenius problem for a class of numerical semigroups
Authors: Gu Ze , Tang Xilin
Published: November 2016

Let [Formula: see text] be two positive integers such that [Formula: see text] and [Formula: see text] the numerical semigroup generated by [Formula: see text]. Then [Formula: see text] is the Thabit numerical semigroup introduced by J. C. Rosales, M. B. Branco and D. Torrão. In this paper, we give formulas for computing the Frobenius number, the genus and the embedding dimension of [Formula: see text].
On the regularity of primes in arithmetic progressions
Authors: Elsholtz Christian , Technau Niclas , Tichy Robert
Published: November 2016

We prove that for a positive integer [Formula: see text] the primes in certain kinds of intervals cannot distribute too “uniformly” among the reduced residue classes modulo [Formula: see text]. Hereby, we prove a generalization of a conjecture of Recaman and establish our results in a much more general situation, in particular for prime ideals in number fields.
Long-term behavior of positive solutions of an exponentially self-regulating system of difference equations
Authors: Psarros N. , Papaschinopoulos G. , Papadopoulos K. B.
Published: November 2016

In this paper, we study the asymptotic behavior of the positive solutions of a system of the following difference equations: [Formula: see text] where [Formula: see text], [Formula: see text], [Formula: see text], [Formula: see text] are positive constants and the initial conditions [Formula: see text] and [Formula: see text] are positive numbers.
Mechanical characteristics of stretchable electronics based on a mogul-patterned structure
Authors: Lee Yeon-Ho , Kim Youn-Jea
Published: November 2016

Recent progress in unconventional forms of foldable and stretchable electronics has enabled development of novel electronics. Especially, stretchable electronics have attracted much interest for applications that require reliable operation under mechanical deformation. Stretchable electrodes can be bent, stretched and compressed while maintaining good performance and structural safety. To realize flexible electronics, stretchability of devices, which requires a deeper understanding of nanoscale materials and mechanics, is needed. In this study, the mechanical characteristics of electrodes based on a mogul-pattern, which retain their electrical conductivity under mechanical deformation, were evaluated. Nanostructured patterns and thin film material were considered for stretched and bent models. The von Mises stress and strain distribution were analyzed and depicted graphically.
Photoelectrocatalytic activity and reaction mechanism of Ag2S/Ag3PO4/Ni nanothin films for rhodamine B
Authors: Zhao Di , Fu Jiali , Liu Yan , Guo Fenghua , Li Aichang
Published: November 2016

Ag2S/Ag3PO4/Ni thin films were prepared using an electrochemical method. The surface morphology, phase structure, optical characteristics and band structure of the thin films were analyzed using scanning electron microscopy (SEM), X-ray diffraction (XRD) and ultraviolet-visible diffuse reflectance spectroscopy (UV–Vis DRS), respectively. Additionally, the films photoelectrocatalytic (PEC) activity and stability were evaluated using rhodamine B (RhB) as a model compound. Ag2S/Ag3PO4/Ni thin films that were prepared under optimum conditions contained nanoparticles that were approximately 25[Formula: see text]nm in size and exhibited high PEC activity. At an optimum cathodic bias of [Formula: see text]0.60[Formula: see text]V, the PEC degradation rate of RhB was 1.93 times greater than that of Ag3PO4/Ni thin film. Especially, the film displayed excellent PEC stability, even after being reused eight times. The possible PEC reactions between the film and RhB under visible-light irradiation are discussed in this paper.
Structurally engineered TiO2–SiO2 monolithic designs for the enhanced photocatalytic degradation of organic textile dye pollutants
Authors: Thejaswini T. V. L. , Prabhakaran D. , Maheswari M. Akhila
Published: November 2016

The rapid removal of organic textile dye (Acid Red-85) using mesoporous TiO2–SiO2 monoliths as photocatalyst material has been studied. The 7:3 mole% ratios of TiO2 and SiO2 within the framework provided a well-ordered cage-like monolithic design with high surface area and pore volume that facilitated faster and efficient degradation of the dye effluents. The photocatalyst has been characterized using XRD, TEM-SAED, UV–Vis-DRS, PL, TGA and BET analysis. The influence of various photocatalytic operational parameters, such as solution pH, dopant stoichiometry, catalyst dosage, dye concentration, kinetics, photo-oxidizers, etc., which could influence on the degradation efficiency, has been studied.
Morphotectonic expression of geological structures in the eastern part of the South East Deccan Volcanic Province (around Nanded, Maharashtra, India)
Authors: Kaplay R. D. , Babar M. D. , Mukherjee Soumyajit , Vijay Kumar T.
Published: November 2016

We geomorphometrically characterize the tectonics near the microseismically active Nanded region, Maharashtra, India. We used the geomorphic indices of active tectonics in 32 sub-basins to evaluate the relationship between tectonics and basin morphology. The area is divided into three different zones (1, 2 and 3). Microseismicity is concentrated along the NW–SE-trending Urvashi Ghat Lineament. The anomalous drainages and lineaments are also confined to the region where microseismicity is associated with thrust. Spatial analysis of the elongation ratio and hypsometric integral of the basins provide valuable information on their distribution and relationship to the structure and tectonics. This study suggests neotectonic control on the evolution of the basins close to Nanded City.
Compilation and appraisal of geochronological data from the North Atlantic Igneous Province (NAIP)
Authors: Wilkinson Camilla M. , Ganerød Morgan , Hendriks Bart W. H. , Eide Elizabeth A.
Published: November 2016

The North Atlantic Igneous Province (NAIP), composed of volcanic sequences and intrusive rocks, occurs onshore in Greenland, the Faeroe Islands, the UK and Ireland, and offshore surrounding these areas as well as the west coast of Norway. Geochronological data have been published for Cenozoic igneous and volcanic rocks for much of the province, and provide valuable information to analyse the evolution of the province and magmatic processes more broadly. As part of the NE Atlantic Geosciences (NAG) cooperation, we examined approximately 700 dates from over 70 published studies and created a comprehensive database to facilitate ready access to this important information. This includes U–Pb, Rb–Sr, Re–Os,
40
Ar/
39
Ar and K–Ar ages presented relative to the Geological Time Scale 2012.
40
Ar/
39
Ar and K–Ar ages have been recalculated to a common reference. The complete database includes data that range from approximately 177 to 0.19 Ma. Our evaluation shows that variable sample quality, ambiguous data-handling methods, inadequate data reporting and data interpretation should preclude the use of data for purposes of rigorous geochronological analysis. Through a series of filtering techniques described here, we suggest excluding >500 dates as being of too poor a quality to use in age determinations. Our analysis highlights the need for published geochronological studies to include sufficient information to allow critical assessment of ages and interpretations. We present an ‘optimized’ dataset containing 130 ages that range from approximately 64 to 13 Ma. The filtered dataset emphasizes the need for firm chronological benchmarks and suggests that some sub-provinces in the NAIP would greatly benefit from renewed research attention.

Supplementary material:
The full NAG-TEC Geochronological Database 001 and Data Evaluation 002 are available at
https://doi.org/10.6084/m9.figshare.c.3554472
Compiling a high-level language for GPUs
Authors: Dubach Christophe , Cheng Perry , Rabbah Rodric , Bacon David F. , Fink Stephen J.
Published: November 2016

Languages such as OpenCL and CUDA offer a standard interface for general-purpose programming of GPUs. However, with these languages, programmers must explicitly manage numerous low-level details involving communication and synchronization. This burden makes programming GPUs difficult and error-prone, rendering these powerful devices inaccessible to most programmers.

We desire a higher-level programming model that makes GPUs more accessible while also effectively exploiting their computational power. This paper presents features of Lime, a new Java-compatible language targeting heterogeneous systems, that allow an optimizing compiler to generate high quality GPU code. The key insight is that the language type system enforces isolation and immutability invariants that allow the compiler to optimize for a GPU without heroic compiler analysis.

Our compiler attains GPU speedups between 75% and 140% of the performance of native OpenCL code.
Language-based control and mitigation of timing channels
Authors: Zhang Danfeng , Askarov Aslan , Myers Andrew C.
Published: November 2016

We propose a new language-based approach to mitigating timing channels. In this language, well-typed programs provably leak only a bounded amount of information over time through external timing channels. By incorporating mechanisms for predictive mitigation of timing channels, this approach also permits a more expressive programming model. Timing channels arising from interaction with underlying hardware features such as instruction caches are controlled. Assumptions about the underlying hardware are explicitly formalized, supporting the design of hardware that efficiently controls timing channels. One such hardware design is modeled and used to show that timing channels can be controlled in some simple programs of real-world significance.
Parcae
Authors: Raman Arun , Zaks Ayal , Lee Jae W. , August David I.
Published: November 2016

Workload, platform, and available resources constitute a parallel program's execution environment. Most parallelization efforts statically target an anticipated range of environments, but performance generally degrades outside that range. Existing approaches address this problem with dynamic tuning but do not optimize a multiprogrammed system holistically. Further, they either require manual programming effort or are limited to array-based data-parallel programs.

This paper presents Parcae, a generally applicable automatic system for platform-wide dynamic tuning. Parcae includes (i) the Nona compiler, which creates flexible parallel programs whose tasks can be efficiently reconfigured during execution; (ii) the Decima monitor, which measures resource availability and system performance to detect change in the environment; and (iii) the Morta executor, which cuts short the life of executing tasks, replacing them with other functionally equivalent tasks better suited to the current environment. Parallel programs made flexible by Parcae outperform original parallel implementations in many interesting scenarios.
Design and implementation of sparse global analyses for C-like languages
Authors: Oh Hakjoo , Heo Kihong , Lee Wonchan , Lee Woosuk , Yi Kwangkeun
Published: November 2016

In this article we present a general method for achieving global static analyzers that are precise, sound, yet also scalable. Our method generalizes the sparse analysis techniques on top of the abstract interpretation framework to support relational as well as non-relational semantics properties for C-like languages. We first use the abstract interpretation framework to have a global static analyzer whose scalability is unattended. Upon this underlying sound static analyzer, we add our generalized sparse analysis techniques to improve its scalability while preserving the precision of the underlying analysis. Our framework determines what to prove to guarantee that the resulting sparse version should preserve the precision of the underlying analyzer.

We formally present our framework; we present that existing sparse analyses are all restricted instances of our framework; we show more semantically elaborate design examples of sparse non-relational and relational static analyses; we present their implemen- tation results that scale to analyze up to one million lines of C programs. We also show a set of implementation techniques that turn out to be critical to economically support the sparse analysis process.
Fast and precise hybrid type inference for JavaScript
Authors: Hackett Brian , Guo Shu-yu
Published: November 2016

JavaScript performance is often bound by its dynamically typed nature. Compilers do not have access to static type information, making generation of efficient, type-specialized machine code difficult. We seek to solve this problem by inferring types. In this paper we present a hybrid type inference algorithm for JavaScript based on points-to analysis. Our algorithm is
fast
, in that it pays for itself in the optimizations it enables. Our algorithm is also
precise
, generating information that closely reflects the program's actual behavior even when analyzing polymorphic code, by augmenting static analysis with run-time type barriers.

We showcase an implementation for Mozilla Firefox's JavaScript engine, demonstrating both performance gains and viability. Through integration with the just-in-time (JIT) compiler in Firefox, we have improved performance on major benchmarks and JavaScript-heavy websites by up to 50%. Inference-enabled compilation is the default compilation mode as of Firefox 9.
SuperC
Authors: Gazzillo Paul , Grimm Robert
Published: November 2016

C tools, such as source browsers, bug finders, and automated refactorings, need to process two languages: C itself and the preprocessor. The latter improves expressivity through file includes, macros, and static conditionals. But it operates only on tokens, making it hard to even parse both languages. This paper presents a complete, performant solution to this problem. First, a configuration-preserving preprocessor resolves includes and macros yet leaves static conditionals intact, thus preserving a program's variability. To ensure completeness, we analyze all interactions between preprocessor features and identify techniques for correctly handling them. Second, a configuration-preserving parser generates a well-formed AST with static choice nodes for conditionals. It forks new subparsers when encountering static conditionals and merges them again after the conditionals. To ensure performance, we present a simple algorithm for table-driven Fork-Merge LR parsing and four novel optimizations. We demonstrate the effectiveness of our approach on the x86 Linux kernel.
RockSalt
Authors: Morrisett Greg , Tan Gang , Tassarotti Joseph , Tristan Jean-Baptiste , Gan Edward
Published: November 2016

Software-based fault isolation (SFI), as used in Google's Native Client (NaCl), relies upon a conceptually simple machine-code analysis to enforce a security policy. But for complicated architectures such as the x86, it is all too easy to get the details of the analysis wrong. We have built a new checker that is smaller, faster, and has a much reduced trusted computing base when compared to Google's original analysis. The key to our approach is automatically generating the bulk of the analysis from a declarative description which we relate to a formal model of a subset of the x86 instruction set architecture. The x86 model, developed in Coq, is of independent interest and should be usable for a wide range of machine-level verification tasks.
A dynamic program analysis to find floating-point accuracy problems
Authors: Benz Florian , Hildebrandt Andreas , Hack Sebastian
Published: November 2016

Programs using floating-point arithmetic are prone to accuracy problems caused by rounding and catastrophic cancellation. These phenomena provoke bugs that are notoriously hard to track down: the program does not necessarily crash and the results are not necessarily obviously wrong, but often subtly inaccurate. Further use of these values can lead to catastrophic errors.

In this paper, we present a dynamic program analysis that supports the programmer in finding accuracy problems. Our analysis uses binary translation to perform every floating-point computation side by side in higher precision. Furthermore, we use a lightweight slicing approach to track the evolution of errors.

We evaluate our analysis by demonstrating that it catches wellknown floating-point accuracy problems and by analyzing the Spec CFP2006 floating-point benchmark. In the latter, we show how our tool tracks down a catastrophic cancellation that causes a complete loss of accuracy leading to a meaningless program result. Finally, we apply our program to a complex, real-world bioinformatics application in which our program detected a serious cancellation. Correcting the instability led not only to improved quality of the result, but also to an improvement of the program's run time.In this paper, we present a dynamic program analysis that supports the programmer in finding accuracy problems. Our analysis uses binary translation to perform every floating-point computation side by side in higher precision. Furthermore, we use a lightweight slicing approach to track the evolution of errors. We evaluate our analysis by demonstrating that it catches wellknown floating-point accuracy problems and by analyzing the SpecfiCFP2006 floating-point benchmark. In the latter, we show how our tool tracks down a catastrophic cancellation that causes a complete loss of accuracy leading to a meaningless program result. Finally, we apply our program to a complex, real-world bioinformatics application in which our program detected a serious cancellation. Correcting the instability led not only to improved quality of the result, but also to an improvement of the program's run time.
Static analysis and compiler design for idempotent processing
Authors: de Kruijf Marc A. , Sankaralingam Karthikeyan , Jha Somesh
Published: November 2016

Recovery functionality has many applications in computing systems, from speculation recovery in modern microprocessors to fault recovery in high-reliability systems. Modern systems commonly recover using checkpoints. However, checkpoints introduce overheads, add complexity, and often save more state than necessary.

This paper develops a novel compiler technique to recover program state without the overheads of explicit checkpoints. The technique breaks programs into
idempotent regions
---regions that can be freely re-executed---which allows recovery without checkpointed state. Leveraging the property of idempotence, recovery can be obtained by simple re-execution. We develop static analysis techniques to construct these regions and demonstrate low overheads and large region sizes for an LLVM-based implementation. Across a set of diverse benchmark suites, we construct idempotent regions close in size to those that could be obtained with perfect runtime information. Although the resulting code runs more slowly, typical performance overheads are in the range of just 2-12%.

The paradigm of executing entire programs as a series of idempotent regions we call
idempotent processing
, and it has many applications in computer systems. As a concrete example, we demonstrate it applied to the problem of compiler-automated hardware fault recovery. In comparison to two other state-of-the-art techniques, redundant execution and checkpoint-logging, our idempotent processing technique outperforms both by over 15%.
Effective parallelization of loops in the presence of I/O operations
Authors: Feng Min , Gupta Rajiv , Neamtiu Iulian
Published: November 2016

Software-based thread-level parallelization has been widely studied for exploiting data parallelism in purely computational loops to improve program performance on multiprocessors. However, none of the previous efforts deal with efficient parallelization of
hybrid loops
, i.e., loops that contain a mix of computation and I/O operations. In this paper, we propose a set of techniques for efficiently parallelizing hybrid loops. Our techniques apply DOALL parallelism to hybrid loops by breaking the cross-iteration dependences caused by I/O operations. We also support speculative execution of I/O operations to enable speculative parallelization of hybrid loops. Helper threading is used to reduce the I/O bus contention caused by the improved parallelism. We provide an easy-to-use programming model for exploiting parallelism in loops with I/O operations. Parallelizing hybrid loops using our model requires few modifications to the code. We have developed a prototype implementation of our programming model. We have evaluated our implementation on a 24-core machine using eight applications, including a widely-used genomic sequence assembler and a multi-player game server, and others from PARSEC and SPEC CPU2000 benchmark suites. The hybrid loops in these applications take 23%-99% of the total execution time on our 24-core machine. The parallelized applications achieve speedups of 3.0x-12.8x with hybrid loop parallelization over the sequential versions of the same applications. Compared to the versions of applications where only computation loops are parallelized, hybrid loop parallelization improves the application performance by 68% on average.
Engineering mathematics
Authors: Gonthier Georges
Published: November 2016

Even with the assistance of computer tools, the formalized de-scription and verification of research-level mathematics remains a daunting task, not least because of the talent with which mathema-ticians combine diverse theories to achieve their ends. By combin-ing tools and techniques from type theory, language design, and software engineering we have managed to capture enough of these practices to formalize the proof of the Odd Order theorem, a landmark result in Group Theory.
Cache and I/O efficent functional algorithms
Authors: Blelloch Guy E. , Harper Robert
Published: November 2016

The widely studied I/O and ideal-cache models were developed to account for the large difference in costs to access memory at different levels of the memory hierarchy. Both models are based on a two level memory hierarchy with a fixed size primary memory(cache) of size M, an unbounded secondary memory organized in blocks of size B. The cost measure is based purely on the number of block transfers between the primary and secondary memory. All other operations are free. Many algorithms have been analyzed in these models and indeed these models predict the relative performance of algorithms much more accurately than the standard RAM model. The models, however, require specifying algorithms at a very low level requiring the user to carefully lay out their data in arrays in memory and manage their own memory allocation.

In this paper we present a cost model for analyzing the memory efficiency of algorithms expressed in a simple functional language. We show how some algorithms written in standard forms using just lists and trees (no arrays) and requiring no explicit memory layout or memory management are efficient in the model. We then describe an implementation of the language and show provable bounds for mapping the cost in our model to the cost in the ideal-cache model. These bound imply that purely functional programs based on lists and trees with no special attention to any details of memory layout can be as asymptotically as efficient as the carefully designed imperative I/O efficient algorithms. For example we describe an O(n_B logM/Bn_B)cost sorting algorithm, which is optimal in the ideal cache and I/O models.
On the linear ranking problem for integer linear-constraint loops
Authors: Ben-Amram Amir M. , Genaim Samir
Published: November 2016

In this paper we study the complexity of the Linear Ranking problem: given a loop, described by linear constraints over a finite set of integer variables, is there a linear ranking function for this loop? While existence of such a function implies termination, this problem is not equivalent to termination. When the variables range over the rationals or reals, the Linear Ranking problem is known to be PTIME decidable. However, when they range over the integers, whether for single-path or multipath loops, the complexity of the Linear Ranking problem has not yet been determined. We show that it is coNP-complete. However, we point out some special cases of importance of PTIME complexity. We also present complete algorithms for synthesizing linear ranking functions, both for the general case and the special PTIME cases.
Automating relatively complete verification of higher-order functional programs
Authors: Unno Hiroshi , Terauchi Tachio , Kobayashi Naoki
Published: November 2016

We present an automated approach to relatively completely verifying safety (i.e., reachability) property of higher-order functional programs. Our contribution is two-fold. First, we extend the refinement type system framework employed in the recent work on (incomplete) automated higher-order verification by drawing on the classical work on relatively complete "Hoare logic like" program logic for higher-order procedural languages. Then, by adopting the recently proposed techniques for solving constraints over quantified first-order logic formulas, we develop an automated type inference method for the type system, thereby realizing an automated relatively complete verification of higher-order programs.
Quantitative abstraction refinement
Authors: Cerny Pavol , Henzinger Thomas A. , Radhakrishna Arjun
Published: November 2016

We propose a general framework for abstraction with respect to quantitative properties, such as worst-case execution time, or power consumption. Our framework provides a systematic way for counter-example guided abstraction refinement for quantitative properties. The salient aspect of the framework is that it allows anytime verification, that is, verification algorithms that can be stopped at any time (for example, due to exhaustion of memory), and report approximations that improve monotonically when the algorithms are given more time.

We instantiate the framework with a number of quantitative abstractions and refinement schemes, which differ in terms of how much quantitative information they keep from the original system. We introduce both state-based and trace-based quantitative abstractions, and we describe conditions that define classes of quantitative properties for which the abstractions provide over-approximations. We give algorithms for evaluating the quantitative properties on the abstract systems. We present algorithms for counter-example based refinements for quantitative properties for both state-based and segment-based abstractions. We perform a case study on worst-case execution time of executables to evaluate the anytime verification aspect and the quantitative abstractions we proposed.
Universal properties of impure programming languages
Authors: Staton Sam , Levy Paul Blain
Published: November 2016

We investigate impure, call-by-value programming languages. Our first language only has variables and let-binding. Its equational theory is a variant of Lambek's theory of multicategories that omits the commutativity axiom.

We demonstrate that type constructions for impure languages --- products, sums and functions --- can be characterized by universal properties in the setting of 'premulticategories', multicategories where the commutativity law may fail. This leads us to new, universal characterizations of two earlier equational theories of impure programming languages: the premonoidal categories of Power and Robinson, and the monad-based models of Moggi. Our analysis thus puts these earlier abstract ideas on a canonical foundation, bringing them to a new, syntactic level.
Meta-theory à la carte
Authors: Delaware Benjamin , d. S. Oliveira Bruno C. , Schrijvers Tom
Published: November 2016

Formalizing meta-theory, or proofs about programming languages, in a proof assistant has many well-known benefits. Unfortunately, the considerable effort involved in mechanizing proofs has prevented it from becoming standard practice. This cost can be amortized by reusing as much of existing mechanized formalizations as possible when building a new language or extending an existing one. One important challenge in achieving reuse is that the inductive definitions and proofs used in these formalizations are closed to extension. This forces language designers to cut and paste existing definitions and proofs in an ad-hoc manner and to expend considerable effort to patch up the results.

The key contribution of this paper is the development of an induction technique for extensible Church encodings using a novel reinterpretation of the universal property of folds. These encodings provide the foundation for a framework, formalized in Coq, which uses type classes to automate the composition of proofs from modular components. This framework enables a more structured approach to the reuse of meta-theory formalizations through the composition of modular inductive definitions and proofs.

Several interesting language features, including binders and general recursion, illustrate the capabilities of our framework. We reuse these features to build fully mechanized definitions and proofs for a number of languages, including a version of mini-ML. Bounded induction enables proofs of properties for non-inductive semantic functions, and mediating type classes enable proof adaptation for more feature-rich languages.
A theorem prover for Boolean BI
Authors: Park Jonghyun , Seo Jeongbong , Park Sungwoo
Published: November 2016

While separation logic is acknowledged as an enabling technology for large-scale program verification, most of the existing verification tools use only a fragment of separation logic that excludes separating implication. As the first step towards a verification tool using full separation logic, we develop a nested sequent calculus for Boolean BI (Bunched Implications), the underlying theory of separation logic, as well as a theorem prover based on it. A salient feature of our nested sequent calculus is that its sequent may have not only smaller child sequents but also multiple parent sequents, thus producing a graph structure of sequents instead of a tree structure. Our theorem prover is based on backward search in a refinement of the nested sequent calculus in which weakening and contraction are built into all the inference rules. We explain the details of designing our theorem prover and provide empirical evidence of its practicality.
Fault tolerance via idempotence
Authors: Ramalingam Ganesan , Vaswani Kapil
Published: November 2016

Building distributed services and applications is challenging due to the pitfalls of distribution such as process and communication failures. A natural solution to these problems is to detect potential failures, and retry the failed computation and/or resend messages. Ensuring correctness in such an environment requires distributed services and applications to be idempotent.

In this paper, we study the inter-related aspects of process failures, duplicate messages, and idempotence. We first introduce a simple core language (based on lambda calculus inspired by modern distributed computing platforms. This language formalizes the notions of a service, duplicate requests, process failures, data partitioning, and local atomic transactions that are restricted to a single store.

We then formalize a desired (generic) correctness criterion for applications written in this language, consisting of idempotence (which captures the desired safety properties) and failure-freedom (which captures the desired progress properties).

We then propose language support in the form of a monad that automatically ensures failfree idempotence. A key characteristic of our implementation is that it is decentralized and does not require distributed coordination. We show that the language support can be enriched with other useful constructs, such as compensations, while retaining the coordination-free decentralized nature of the implementation.

We have implemented the idempotence monad (and its variants) in F# and C# and used our implementation to build realistic applications on Windows Azure. We find that the monad has low runtime overheads and leads to more declarative applications.
The type discipline of behavioral separation
Authors: Caires Luís , Seco João C.
Published: November 2016

We introduce the concept of behavioral separation as a general principle for disciplining interference in higher-order imperative concurrent programs, and present a type-based approach that systematically develops the concept in the context of an ML-like language extended with concurrency and synchronization primitives. Behavioral separation builds on notions originally introduced for behavioral type systems and separation logics, but shifts the focus from the separation of static program state properties towards the separation of dynamic usage behaviors of runtime values. Behavioral separation types specify how values may be safely used by client code, and can enforce fine-grained interference control disciplines while preserving compositionality, information hiding, and flexibility. We illustrate how our type system, even if based on a small set of general primitives, is already able to tackle fairly challenging program idioms, involving aliasing at various types, concurrency with first-class threads, manipulation of linked data structures, behavioral borrowing, and invariant-based separation.