Fuzzy Set Abstraction

Program analysis plays a key part in improving modern software. Static (sound) analyses produce globally correct, but often pessimistic results while dynamic (complete) analyses yield highly precise results but with limited coverage. We present the Fuzzy set abstraction which generalizes previous work based on 3-valued logic. Our abstraction allows for hybrid analysis where static results are refined dynamically through the use of fuzzy control systems

ROSE::FTTransform - A source-to-source translation framework for exascale fault-tolerance research

Exascale computing systems will require sufficient resilience to tolerate numerous types of hardware faults while still assuring correct program execution. Such extreme-scale machines are expected to be dominated by processors driven at lower voltages (near the minimum 0.5 volts for current transistors). At these voltage levels, the rate of transient errors increases dramatically due to the sensitivity to transient and geographically localized voltage drops on parts of the processor chip. To achieve power efficiency, these processors are likely to be streamlined and minimal, and thus they cannot be expected to handle transient errors entirely in hardware. Here we present an open, compiler-based framework to automate the armoring of High Performance Computing (HPC) software to protect it from these types of transient processor errors. We develop an open infrastructure to support research work in this area, and we define tools that, in the future, may provide more complete automated and/or semi-automated solutions to support software resiliency on future exascale architectures. Results demonstrate that our approach is feasible, pragmatic in how it can be separated from the software development process, and reasonably efficient (0% to 30% overhead for the Jacobi iteration on common hardware; and 20%, 40%, 26%, and 2% overhead for a randomly selected subset of benchmarks from the Livermore Loops [1])

Rapidly evolving transients in the Dark Energy Survey

We present the results of a search for rapidly evolving transients in the Dark Energy Survey Supernova Programme. These events are characterized by fast light-curve evolution (rise to peak in≲10 d and exponential decline in≲30 d after peak).We discovered 72 events, including 37 transients with a spectroscopic redshift from host galaxy spectral features. The 37 events increase the total number of rapid optical transients by more than a factor of two. They are found at a wide range of redshifts (0.05 Mg > -22.25). The multiband photometry is well fit by a blackbody up to few weeks after peak. The events appear to be hot (T ≈ 10 000-30 000 K) and large (R ≈ 1014 - 2 × 1015 cm) at peak, and generally expand and cool in time, though some events show evidence for a receding photosphere with roughly constant temperature. Spectra taken around peak are dominated by a blue featureless continuum consistent with hot, optically thick ejecta. We compare our events with a previously suggested physical scenario involving shock breakout in an optically thick wind surrounding a core-collapse supernova, we conclude that current models for such a scenario might need an additional power source to describe the exponential decline. We find that these transients tend to favour star-forming host galaxies, which could be consistent with a core-collapse origin. However, more detailed modelling of the light curves is necessary to determine their physical origin

Revealing the progenitor of SN 2021zby through analysis of the TESSTESS shock-cooling light curve

We present early observations and analysis of the double-peaked Type IIb supernova (SN IIb) 2021zby. $TESS$ captured the prominent early shock cooling peak of SN 2021zby within the first $\sim$10 days after explosion with a 30-minute cadence. We present optical and near-infrared spectral series of SN 2021zby, including three spectra during the shock cooling phase. Using a multi-band model fit, we find that the inferred properties of its progenitor are consistent with a red supergiant or yellow supergiant, with an envelope mass of $\sim$0.3-3.0 M$_\odot$ and an envelope radius of $\sim$50-350$R_\odot$. These inferred progenitor properties are similar to those of other SNe IIb with double-peak feature, such as SNe 1993J, 2011dh, 2016gkg and 2017jgh. This study further validates the importance of the high cadence and early coverage in resolving the shape of the shock cooling light curve, while the multi-band observations, especially UV, is also necessary to fully constrain the progenitor properties.Comment: 12 pages, 5 figures, 2 tables, submitted to ApJ

Multi-messenger observations of a binary neutron star merger

On 2017 August 17 a binary neutron star coalescence candidate (later designated GW170817) with merger time 12:41:04 UTC was observed through gravitational waves by the Advanced LIGO and Advanced Virgo detectors. The Fermi Gamma-ray Burst Monitor independently detected a gamma-ray burst (GRB 170817A) with a time delay of ~1.7 s with respect to the merger time. From the gravitational-wave signal, the source was initially localized to a sky region of 31 deg2 at a luminosity distance of 40+8-8 Mpc and with component masses consistent with neutron stars. The component masses were later measured to be in the range 0.86 to 2.26 Mo. An extensive observing campaign was launched across the electromagnetic spectrum leading to the discovery of a bright optical transient (SSS17a, now with the IAU identification of AT 2017gfo) in NGC 4993 (at ~40 Mpc) less than 11 hours after the merger by the One- Meter, Two Hemisphere (1M2H) team using the 1 m Swope Telescope. The optical transient was independently detected by multiple teams within an hour. Subsequent observations targeted the object and its environment. Early ultraviolet observations revealed a blue transient that faded within 48 hours. Optical and infrared observations showed a redward evolution over ~10 days. Following early non-detections, X-ray and radio emission were discovered at the transient’s position ~9 and ~16 days, respectively, after the merger. Both the X-ray and radio emission likely arise from a physical process that is distinct from the one that generates the UV/optical/near-infrared emission. No ultra-high-energy gamma-rays and no neutrino candidates consistent with the source were found in follow-up searches. These observations support the hypothesis that GW170817 was produced by the merger of two neutron stars in NGC4993 followed by a short gamma-ray burst (GRB 170817A) and a kilonova/macronova powered by the radioactive decay of r-process nuclei synthesized in the ejecta

Compiler optimizations in the presence of uncertain semantics

As transistors sizes shrink and architects put more and more cores on chip, computer systems become more susceptible to outside interference. This interference can cause faults that manifest as unexpected and uncontrolled state transitions, possibly leading to costly or harmful consequences. Coping with faults requires introducing some form of redundancy. On the other hand, redundancy is often removed in improving the performance of an application. Compiler optimizations are used to exploit computational capabilities to their full extent. Previously, compiler optimizations often targeted performance, but recently optimizations are being introduced to trade performance for reliability. This thesis presents optimizations that try to improve both performance and reliability, prioritizing one of the other based on need.First, I introduce a framework for semi-automatically adding software fault-tolerance to an application. Using this framework I show that together with an appropriate voting mechanism, redundant executions can increase reliability while keeping performance overhead as low as 18%.Second, I present an algorithm based on geometric programming for minimizing the number of redundant executions in an application while maintaining a reliability threshold. Often a static number of redundant executions per statement is employed throughout the whole application. To minimize performance overhead I exploit that some operations are naturally more reliable, and more costly, than others.Third, I introduce a voting system that adds redundant executions as needed, up to a number decided by our optimization method. Using this scheme, I show improvement in performance and reliability over a scheme where a fixed number of redundant executions is used.Finally, I present an analysis based on abstract interpretation to determine the impact of a finite number of faults. An analysis based on abstract interpretation guarantees logical soundness by construction, and we evaluate its applicability on kernels and corner cases. This analysis could be used to decide where redundant executions are not needed

Program Analysis for Performance and Reliability

The increased demand for computing power has lead designers to put an ever increasing number of cores on processor dies. This advance has been made possible through miniaturization and effectivization of the underlying semi-conductor technology. As a by-product, however, the resulting computer systems are more vulnerable to interference. This has made reliability a first-order concern and is treated both in software and hardware through some form of redundancy. Redundancy is however detrimental to performance leading to more resources spent re-computing. Efficient use of hardware requires software that can take advantage of the computer system. Compilers are responsible for translating high-level source-code into efficient machine-code. Transformations in the compiler can improve performance and/or reliability of the software. Prior to applying such transformation the compiler needs to verify the legality and benefit of this optimization through program analysis.This thesis develops program analyses for reasoning about performance and reliability properties and show how these synthesize information that could not be made available from previous approaches.First, I present an analysis based on abstract interpretation to determine the impactof a finite number of faults. An analysis based on abstract interpretation guaranteeslogical soundness by construction, and I evaluate its applicability by deducing the fault susceptibility of kernels and how a program optimization affect reliability.Second, I present the fuzzy program analysis framework and show that it admits a sound approximation in the abstract interpretation framework. Fuzzy sets allow non-binary membership and, in extension, a qualitative static program analysis that can perform common-case analyses. Furthermore this frameworkadmits a dynamic analysis based on fuzzy control theory that refines the result from the static analysis online.Using the framework I show improvement on a code motion algorithm and several classical program analyses that target performance properties.Third, I present an analysis based on geometric programming for deciding the minimalnumber of redundant executions of an program statement while maintaining a reliabilitythreshold. Often a fixed number of redundant executions per statement is employedthroughout the whole program. To minimize performance overhead I exploit thatsome statements are naturally more reliable, and more costly, than others. Using the analysis I show improvement in reliability and performance overhead due to use of a redundancy level that is tailored for each statement individually

Bridging Static and Dynamic Program Analysis using Fuzzy Logic

Static program analysis is used to summarize properties over all dynamic executions. In a unifying approach based on 3-valued logic properties are either assigned a definite value or unknown. But in summarizing a set of executions, a property is more accurately represented as being biased towards true, or towards false. Compilers use program analysis to determine benefit of an optimization. Since benefit (e.g., performance) is justified based on the common case understanding bias is essential in guiding the compiler. Furthermore, successful optimization also relies on understanding the quality of the information, i.e. the plausibility of the bias. If the quality of the static information is too low to form a decision we would like a mechanism that improves dynamically. We consider the problem of building such a reasoning framework and present the fuzzy data-flow analysis. Our approach generalize previous work that use 3-valued logic. We derive fuzzy extensions of data-flow analyses used by the lazy code motion optimization and unveil opportunities previous work would not detect due to limited expressiveness. Furthermore we show how the results of our analysis can be used in an adaptive classifier that improve as the application executes

Verifying reliability properties using the hyperball abstract domain

Modern systems are increasingly susceptible to soft errors that manifest themselves as bit flips and possibly alter the semantics of an application. We would like to measure the quality degradation on semantics due to such bit flips, and thus we introduce a Hyperball abstract domain that allows us to determine the worst-case distance between expected and actual results. Similar to intervals, hyperballs describe a connected and dense space. The semantics of low-level code in the presence of bit flips is hard to accurately describe in such a space. We therefore combine the Hyperball domain with an existing affine system abstract domain that we extend to handle bit flips, which are introduce as disjunctions. Bit-flips can reduce the precision of our analysis, and we therefor introduce the Scale domain as a disjunctive refinement to minimize precision loss. This domain bounds the number of disjunctive elements by quantifying the over-approximation of different partitions and uses submodular optimization to find a good partitioning (within a bound of optimal).We evaluate these domains to show benefits and potential problems. For the application we examine here, adding the Scale domain to the Hyperball abstraction improves accuracy by up to two orders of magnitude. Our initial results demonstrate the feasibility of this approach, although we would like to further improve execution efficiency