Simuliris: a separation logic framework for verifying concurrent program optimizations

Today’s compilers employ a variety of non-trivial optimizations to achieve good performance. One key trick compilers use to justify transformations of concurrent programs is to assume that the source program has no data races : if it does, they cause the program to have undefined behavior (UB) and give the compiler free rein. However, verifying correctness of optimizations that exploit this assumption is a non-trivial problem. In particular, prior work either has not proven that such optimizations preserve program termination (particularly non-obvious when considering optimizations that move instructions out of loop bodies), or has treated all synchronization operations as external functions (losing the ability to reorder instructions around them). In this work we present Simuliris , the first simulation technique to establish termination preservation (under a fair scheduler) for a range of concurrent program transformations that exploit UB in the source language. Simuliris is based on the idea of using ownership to reason modularly about the assumptions the compiler makes about programs with well-defined behavior. This brings the benefits of concurrent separation logics to the space of verifying program transformations: we can combine powerful reasoning techniques such as framing and coinduction to perform thread-local proofs of non-trivial concurrent program optimizations. Simuliris is built on a (non-step-indexed) variant of the Coq-based Iris framework, and is thus not tied to a particular language. In addition to demonstrating the effectiveness of Simuliris on standard compiler optimizations involving data race UB, we also instantiate it with Jung et al.’s Stacked Borrows semantics for Rust and generalize their proofs of interesting type-based aliasing optimizations to account for concurrency.

An Extended Account of Trace-relating Compiler Correctness and Secure Compilation

Compiler correctness, in its simplest form, is defined as the inclusion of the set of traces of the compiled program in the set of traces of the original program. This is equivalent to the preservation of all trace properties. Here, traces collect, for instance, the externally observable events of each execution. However, this definition requires the set of traces of the source and target languages to be the same, which is not the case when the languages are far apart or when observations are fine-grained. To overcome this issue, we study a generalized compiler correctness definition, which uses source and target traces drawn from potentially different sets and connected by an arbitrary relation. We set out to understand what guarantees this generalized compiler correctness definition gives us when instantiated with a non-trivial relation on traces. When this trace relation is not equality, it is no longer possible to preserve the trace properties of the source program unchanged. Instead, we provide a generic characterization of the target trace property ensured by correctly compiling a program that satisfies a given source property, and dually, of the source trace property one is required to show to obtain a certain target property for the compiled code. We show that this view on compiler correctness can naturally account for undefined behavior, resource exhaustion, different source and target values, side channels, and various abstraction mismatches. Finally, we show that the same generalization also applies to many definitions of secure compilation, which characterize the protection of a compiled program linked against adversarial code.

KymoMerge: a new tool for analysis of multichannel kymographs

Kymograph analysis is commonly used by researchers to study dynamic processes in cells. Current tools widely available only allow for analysis of one channel kymographs. Here we provide a python-coded, open source program to use as a plug-in for ImageJ which creates one kymograph from the kymographs of two separate channels of one time-lapse movie. This add-in, which we call KymoMerge, therefore allows for analysis of only the co-located tracks in multi-channel movies.

EFMlrs: a Python package for elementary flux mode enumeration via lexicographic reverse search

Background Elementary flux mode (EFM) analysis is a well-established, yet computationally challenging approach to characterize metabolic networks. Standard algorithms require huge amounts of memory and lack scalability which limits their application to single servers and consequently limits a comprehensive analysis to medium-scale networks. Recently, Avis et al. developed —a parallel version of the lexicographic reverse search (lrs) algorithm, which, in principle, enables an EFM analysis on high-performance computing environments (Avis and Jordan. mplrs: a scalable parallel vertex/facet enumeration code. arXiv:1511.06487, 2017). Here we test its applicability for EFM enumeration. Results We developed , a Python package that gives users access to the enumeration capabilities of . uses COBRApy to process metabolic models from sbml files, performs loss-free compressions of the stoichiometric matrix, and generates suitable inputs for as well as , providing support not only for our proposed new method for EFM enumeration but also for already established tools. By leveraging COBRApy, also allows the application of additional reaction boundaries and seamlessly integrates into existing workflows. Conclusion We show that due to ’s properties, the algorithm is perfectly suited for high-performance computing (HPC) and thus offers new possibilities for the unbiased analysis of substantially larger metabolic models via EFM analyses. is an open-source program that comes together with a designated workflow and can be easily installed via pip.

Identifying ZooMS Spectra (mammals) using mMass v1

This is a guide to identifying ZooMS spectra for mammals using the open-source program mMass (Niedermeyer and Strohalm 2012). This guide is intended as a learning tool for students and researchers at the University of Tubingen and is not meant to replace formal ZooMS marker training. If you use this guide to analyse your ZooMS spectra or to convert your data into an open-source format, please cite this document. For further information contact Dr. Samantha Brown (samantha.brown (at) uni-tuebingen.de)

Distribution and mapping pulasan (Nephelium ramboutan-ake Bill. Liinh) in Riau ecosystem zone area

Pulasan (Nephelium ramboutan-ake Bill. Liinh.) is one of the genetic sources of the Sapindaceae family which has many benefits, including fresh fruit, processed food industry as well as traditional and modern medicines. Currently, the existence of outward appearance has experienced scarcity, even threatened with extinction. This study aims to determine the distribution and create a map of the outward distribution in the Riau Ecosystem Area. This study uses a survey method, namely the technique of getting outward distribution points by tracking using the Garmin 76csx Global Positioning System (GPS). The data obtained were processed using the Map Source program and ArcGIS 10. The basic map used was a map of the administrative boundaries of Kampar, Kuantan Singingi, Siak and Bengkalis districts as well as a map of soil types. The outward distribution of each sub-district is presented descriptively and in the form of a map. Overlays of germplasm have been explored in as many as 495 trees spread over four districts in Riau. The population of the outward distribution in the mineral soil ecosystem zone is more than the population in the peat soil ecosystem zone. Distributed in groups with unequal populations.

Compiling with continuations, correctly

In this paper we present a novel simulation relation for proving correctness of program transformations that combines syntactic simulations and logical relations. In particular, we establish a new kind of simulation diagram that uses a small-step or big-step semantics in the source language and an untyped, step-indexed logical relation in the target language. Our technique provides a practical solution for proving semantics preservation for transformations that do not preserve reductions in the source language. This is common when transformations generate new binder names, and hence α-conversion must be explicitly accounted for, or when transformations introduce administrative redexes. Our technique does not require reductions in the source language to correspond directly to reductions in the target language. Instead, we enforce a weaker notion of semantic preorder, which suffices to show that semantics are preserved for both whole-program and separate compilation. Because our logical relation is transitive, we can transition between intermediate program states in a small-step fashion and hence the shape of the proof resembles that of a simple small-step simulation. We use this technique to revisit the semantic correctness of a continuation-passing style (CPS) transformation and we demonstrate how it allows us to overcome well-known complications of this proof related to α-conversion and administrative reductions. In addition, by using a logical relation that is indexed by invariants that relate the resource consumption of two programs, we are able show that the transformation preserves diverging behaviors and that our CPS transformation asymptotically preserves the running time of the source program. Our results are formalized in the Coq proof assistant. Our continuation-passing style transformation is part of the CertiCoq compiler for Gallina, the specification language of Coq.

ReLie: A Reduce Program for Lie Group Analysis of Differential Equations

Lie symmetry analysis provides a general theoretical framework for investigating ordinary and partial differential equations. The theory is completely algorithmic even if it usually involves lengthy computations. For this reason, along the years many computer algebra packages have been developed to automate the computation. In this paper, we describe the program ReLie, written in the Computer Algebra System Reduce, since 2008 an open source program for all platforms. ReLie is able to perform almost automatically the needed computations for Lie symmetry analysis of differential equations. Its source code is freely available too. The use of the program is illustrated by means of some examples; nevertheless, it is to be underlined that it proves effective also for more complex computations where one has to deal with very large expressions.

Test Automation of Web Application Login Page by Using Selenium Ide in a Web Browser

Selenium stands as open-source program apparatus aimed at computerization testing. Here, selenium-IDE (Integrated Developments Environment) Testing is investigated, which could be a remarkably vital movement in Program Improvement Handle. It is to look at and alter source code. A high-quality computer program can well be achieved by producing Compelling Testing. This Paper handles a critical in addition to the crucial issue of Program Testing. Testing can well be executed both manually and automatically. This paper sets to do Mechanization Testing through "Selenium". Test cases (TC) are consequently recorded with this web testing tool whilst the analyzer is entering the information in a web application screen.