Search

Verifying invariants of fine-grained concurrent data structures is challenging, because interference from other threads may occur at any time. We propose a new way of proving invariants of fine-grained concurrent data structures: applying rely-guarantee reasoning to references in the concurrent setting. Rely-guarantee applied to references can verify bounds on thread interference without requiring a whole program to be verified. This article provides three new results. First, it provides a new approach to preserving invariants and restricting usage of concurrent data structures. Our approach targets a space between simple type systems and modern concurrent program logics, offering an intermediate point between unverified code and full verification. Furthermore, it avoids sealing concurrent data structure implementations and can interact safely with unverified imperative code. Second, we demonstrate the approach’s broad applicability through a series of case studies, using two implementations: an axiomatic C oq domain-specific language and a library for Liquid Haskell. Third, these two implementations allow us to compare and contrast verifications by interactive proof (C oq ) and a weaker form that can be expressed using automatically-discharged dependent refinement types (Liquid Haskell).

snmalloc is an implementation of malloc aimed at workloads in which objects are typically deallocated by a different thread than the one that had allocated them. We use the term producer/consumer for such workloads. snmalloc uses a novel message passing scheme which returns deallocated objects to the originating allocator in batches without taking any locks. It also uses a novel bump pointer-free list data structure with which just 64-bits of meta-data are sufficient for each 64 KiB slab. On such producer/consumer benchmarks our approach performs better than existing allocators. Snmalloc is available at https://github.com/Microsoft/snmalloc.

The influence of polymerization temperature (Tp) on the isoselectivity of the C2-symmetric zirconocene catalysts rac-Me2Si(2-Me-4-PhInd)2ZrCl2/MAO (1/MAO), rac-Me(CyHex)Si[2-Me-4-(4′-tBuPh)Ind]2ZrCl2/MAO (2/MAO), and rac-Me2Si(2-Me-4-Ph-5-OMe-6-tBuInd)2ZrCl2/MAO (3/MAO) in propene polymerization, has been studied in the range 30–85 °C in liquid propene. All three catalysts show similar polymerization activity versus Tp profiles, with a maximum at about 60 °C (1/MAO), 80−85 °C (2/MAO), and 70−80 °C (3/MAO). 3/MAO shows the highest activity at any Tp. The isoselectivity of the three catalysts remains high and approximately constant in the whole Tp range investigated, as indicated by the roughly constant isotactic triad content (mm > 99%) of the produced isotactic poly(propylene)s (iPP). Surprisingly, the melting and crystallization temperatures of iPP increase by increasing TP. This behavior is due to an unexpected increase in catalyst regioselectivity with Tp, as indicated by the decrease in the content of 2,1-erythro regiodefects (2,1e) at increasing Tp. A mechanism involving a metal cation–2,1-coordinated propene slow state is proposed to account for this so far unnoticed behavior. The correlations between Tp, Tm, and [2,1e] are defined for these three catalysts.

Synchronization constructs lie at the heart of any reliable concurrent program. Many such constructs are standard (e.g., locks, queues, stacks, and hash-tables). However, many concurrent applications require custom synchronization constructs with special-purpose behavior. These constructs present a significant challenge for verification. Like standard constructs, they rely on subtle racy behavior, but unlike standard constructs, they may not have well-understood abstract interfaces. As they are custom built, such constructs are also far more likely to be unreliable. This article examines the formal specification and verification of custom synchronization constructs. Our target is a library of channels used in automated parallelization to enforce sequential behavior between program statements. Our high-level specification captures the conditions necessary for correct execution; these conditions reflect program dependencies necessary to ensure sequential behavior. We connect the high-level specification with the low-level library implementation to prove that a client’s requirements are satisfied. Significantly, we can reason about program and library correctness without breaking abstraction boundaries. To achieve this, we use a program logic called iCAP (impredicative Concurrent Abstract Predicates) based on separation logic. iCAP supports both high-level abstraction and low-level reasoning about races. We use this to show that our high-level channel specification abstracts three different, increasingly complex low-level implementations of the library. iCAP’s support for higher-order reasoning lets us prove that sequential dependencies are respected, while iCAP’s next-generation semantic model lets us avoid ugly problems with cyclic dependencies.

We describe modern variants of Monte Carlo methods for Uncertainty Quantification (UQ) of the Neutron Transport Equation, when it is approximated by the discrete ordinates method with diamond differencing. We focus on the mono-energetic 1D slab geometry problem, with isotropic scattering, where the cross-sections are log-normal correlated random fields of possibly low regularity. The paper includes an outline of novel theoretical results on the convergence of the discrete scheme, in the cases of both spatially variable and random cross-sections. We also describe the theory and practice of algorithms for quantifying the uncertainty of a functional of the scalar flux, using Monte Carlo and quasi-Monte Carlo methods, and their multilevel variants. A hybrid iterative/direct solver for computing each realisation of the functional is also presented. Numerical experiments show the effectiveness of the hybrid solver and the gains that are possible through quasi-Monte Carlo sampling and multilevel variance reduction. For the multilevel quasi-Monte Carlo method, we observe gains in the computational e-cost of up to two orders of magnitude over the standard Monte Carlo method, and we explain this theoretically. Experiments on problems with up to several thousand stochastic dimensions are included.

Safe programming languages are readily available, but many applications continue to be written in unsafe languages because of efficiency. As a consequence, many applications continue to have exploitable memory safety bugs. Since garbage collection is a major source of inefficiency in the implementation of safe languages, replacing it with safe manual memory management would be an important step towards solving this problem. Previous approaches to safe manual memory management use programming models based on regions, unique pointers, borrowing of references, and ownership types. We propose a much simpler programming model that does not require any of these concepts. Starting from the design of an imperative type safe language (like Java or C#), we just add a delete operator to free memory explicitly and an exception which is thrown if the program dereferences a pointer to freed memory. We propose an efficient implementation of this programming model that guarantees type safety. Experimental results from our implementation based on the C# native compiler show that this design achieves up to 3x reduction in peak working set and run time.

Stereoblock polypropylenes comprising of iPP and sPP segments are synthesized by polymerization of the following binary system of metallocenes: the Cs-symmetric [2,7-t-Bu2(Flu)2Ph2C(Cp)ZrCl2] and the C2-symmetric rac-Me2Si(2-Me-4-Ph-Ind)2ZrCl2. Blends of samples made either by each catalyst individually (solution blend) with materials obtained with the mixed catalyst system (reactor blend) are compared. The simultaneous presence of MAO and DEZ, enhancing fast and reversible transfer of the growing chains between the two active centers, leads to the formation of a stereoblock microstructure. In this case, low molecular weight polymers are obtained. The junction between the blocks is qualitatively observed in 13C NMR. When made in toluene, the stereoblock material consists of a majority of syndiotactic sequences, whereas the ratio is more equilibrated when the polymerization was conducted in the more polar chlorobenzene. This is confirmed by the results obtained with 13C NMR, CRYSTAF, HT HPLC, DSC, SSA, WAXD, and optical microscopy. © 2014 Wiley Periodicals, Inc. J. Polym. Sci., Part A: Polym. Chem. 2014, 52, 1422–1434

A better understanding of structure-property relations is necessary to design novel materials. In this study, we investigate the morphology and chemical structure of five commercial grades of propylene-based polymers in relation to the change in yield- stress as a function of strain-rate. Substantial emphasis has been laid on understanding the chain microstructure in the relation to chain dynamics in the amorphous phase. Heterogeneous Ziegler–Natta catalysis was used to prepare the samples with differing ratios of propylene and ethylene units. Various analytical techniques such as WAXS, SAXS, solution- and solid-state NMR were employed to characterize their structure. The results indicate a reduction in crystallinity, melting temperature, long-period and crystal thickness with increasing ethylene content. Solid-state NMR data reveal the presence of four components in these samples, which is an extension of the traditional three phase model found in most semi-crystalline polymers. The additional fourth phase is attributed to a rubber-like component that is primarily composed of chain segments rich in ethylene units and shows an increase in chain dynamics with increasing ethylene content in the samples. Mechanical experiments show that yield stress decreases with increase in the amount ethylene which can be correlated to the observed increase in chain dynamics in the amorphous phase.

Modern program logics have made it feasible to verify the most complex concurrent algorithms. However, many such logics are complex, and most lack automated tool support. We propose Starling, a new lightweight logic and automated tool for concurrency verification. Starling takes a proof outline written in an abstracted Hoare-logic style, and converts it into proof terms that can be discharged by a sequential solver. Starling’s approach is generic in its structure, making it easy to target different solvers. In this paper we verify shared-variable algorithms using the Z3 SMT solver, and heap-based algorithms using the GRASShopper solver. We have applied our approach to a range of concurrent algorithms, including Rust’s atomic reference counter, the Linux ticketed lock, the CLH queue-lock, and a fine-grained list algorithm.

Linearizability is the commonly accepted notion of correctness for concurrent data structures. It requires that any execution of the data structure is justified by a linearization--a linear order on operations satisfying the data structure's sequential specification. Proving linearizability is often challenging because an operation's position in the linearization order may depend on future operations. This makes it very difficult to incrementally construct the linearization in a proof. We propose a new proof method that can handle data structures with such future-dependent linearizations. Our key idea is to incrementally construct not a single linear order of operations, but a partial order that describes multiple linearizations satisfying the sequential specification. This allows decisions about the ordering of operations to be delayed, mirroring the behaviour of data structure implementations. We formalise our method as a program logic based on rely-guarantee reasoning, and demonstrate its effectiveness by verifying several challenging data structures: the Herlihy-Wing queue, the TS queue and the Optimistic set.

Compositional abstractions underly many reasoning principles for concurrent programs: the concurrent environment is abstracted in order to reason about a thread in isolation; and these abstractions are composed to reason about a program consisting of many threads. For instance, separation logic uses formulae that describe part of the state, abstracting the rest; when two threads use disjoint state, their specifications can be composed with the separating conjunction. Type systems abstract the state to the types of variables; threads may be composed when they agree on the types of shared variables. In this paper, we present the "Concurrent Views Framework", a metatheory of concurrent reasoning principles. The theory is parameterised by an abstraction of state with a notion of composition, which we call views. The metatheory is remarkably simple, but highly applicable: the rely-guarantee method, concurrent separation logic, concurrent abstract predicates, type systems for recursive references and for unique pointers, and even an adaptation of the Owicki-Gries method can all be seen as instances of the Concurrent Views Framework. Moreover, our metatheory proves each of these systems is sound without requiring induction on the operational semantics.

In 2004, Berdine, Calcagno and O'Hearn introduced a fragment of separation logic that allows for reasoning about programs with pointers and linked lists. They showed that entailment in this fragment is in coNP, but the precise complexity of this problem has been open since. In this paper, we show that the problem can actually be solved in polynomial time. To this end, we represent separation logic formulae as graphs and show that every satisfiable formula is equivalent to one whose graph is in a particular normal form. Entailment between two such formulae then reduces to a graph homomorphism problem. We also discuss natural syntactic extensions that render entailment intractable. © 2011 Springer-Verlag.

Low molecular weight homopolypropylene and ethylene–propylene copolymers with low ethylene content have been produced with a highly stereoselective metallocene catalyst in the presence of dihydrogen. Quantitative 13C NMR analysis allowed the detection of regioirregular (2,1-insertions) propylene units both in propylene homosequences and in ethylene–propylene sequences, and of different types of end groups. The microstructure of the polymers has been correlated with polymerization mechanisms, and the effect of ethylene on polymer regioregularity, termination and initiation steps has been investigated. The amount of 2,1-misinserted propylene units followed by one ethylene unit increases with increasing ethylene content in the polymer, which confirms that ethylene insertion after a 2,1-misinsertion is favored over propylene 1,2-insertion. Additionally, addition of ethylene reduces the frequency of secondary insertions. Under the investigated polymerization conditions, the dominating termination route was cha...

Behavioral interface specification languages provide formal code-level annotations, such as preconditions, postconditions, invariants, and assertions that allow programmers to express the intended behavior of program modules. Such specifications are useful for precisely documenting program behavior, for guiding implementation, and for facilitating agreement between teams of programmers in modular development of software. When used in conjunction with automated analysis and program verification tools, such specifications can support detection of common code vulnerabilities, capture of light-weight application-specific semantic properties, generation of test cases and test oracles, and full formal program verification. This article surveys behavioral interface specification languages with a focus toward automatic program verification and with a view towards aiding the Verified Software Initiative—a fifteen-year, cooperative, international project directed at the scientific challenges of large-scale software verification.

The recently developed approach of Transition Moment Orientation Analysis is employed to determine the three dimensional orientation and order of the different molecular moieties in semi-crystalline polyolefins. Based on IR transmission spectra for varying polarisation and inclination the quadratically averaged orientation distribution of the different IR transition moments is deduced. By that, the full order parameter tensor and its orientation with respect to the sample coordinate system is obtained.

The flow response of branched entangled resins is dominated by the branching topology of the constituent molecules, a property that is not directly accessible using experimental analytical tools for industrially relevant complex resins. In this paper, the controlled terpolymerization of ethylene, 1,9-decadiene, and either hexene or octene in a continuous stirred tank reactor with a metallocene catalyst, is reported. The synthesized samples are characterized extensively with various analytical tools and their rheological properties are measured with small amplitude oscillatory shear and start-up uniaxial extension experiments. A model is developed for the polymerization process with the mass balance during synthesis providing strong constraints on the rate constants. In silico ensembles of molecules, generated via Monte Carlo sampling, are used to reproduce the experimental results. The computer model allows us to infer the detailed branching structure of the molecules and to predict the optimum range of reactor conditions for this synthesis.

Weaving a concurrency control protocol into a program is difficult and error-prone. One way to alleviate this burden is deterministic parallelism . In this well-studied approach to parallelisation, a sequential program is annotated with sections that can execute concurrently, with automatically injected control constructs used to ensure observable behaviour consistent with the original program. This paper examines the formal specification and verification of these constructs. Our high-level specification defines the conditions necessary for correct execution; these conditions reflect program dependencies necessary to ensure deterministic behaviour. We connect the high-level specification used by clients of the library with the low-level library implementation, to prove that a client's requirements for determinism are enforced. Significantly, we can reason about program and library correctness without breaking abstraction boundaries. To achieve this, we use concurrent abstract predicates , based on separation logic, to encapsulate racy behaviour in the library's implementation. To allow generic specifications of libraries that can be instantiated by client programs, we extend the logic with higher-order parameters and quantification. We show that our high-level specification abstracts the details of deterministic parallelism by verifying two different low-level implementations of the library.

This paper presents a methodology for automated modular verification of C programs against specifications written in separation logic. The distinguishing features of the approach are representation of the C memory model in separation logic by means of rewrite rules suitable for automation and the careful integration of an SMT solver behind the separation logic prover to guide the proof search.

Chain branching has been investigated in a homologous series of poly( n -alkyl acrylates) (methyl, ethyl, n -butyl, n -hexyl) obtained by radical polymerization. The total amount of chain branching was quantified using melt-state 13 C nuclear magnetic resonance (NMR) spectroscopy. It gave access to low degrees of branching in both soluble and insoluble polyacrylates, homopolymers and copolymers. The lowest degree of branching was found for the ethyl member of the series with quantification by conventional solution-state NMR found to take a prohibitively long time. The method proposed here is compared to the ones published previously, and previous literature results are critically reviewed. The presence of long-chain branching (LCB) was selectively detected using multiple-detection size-exclusion chromatography (SEC), with LCB being found for all soluble homopolymers but the poly( n -butyl acrylate). This finding was confirmed by close examination of the Mark–Houwink parameters for the various polyacrylates studied in this work or those previously published.

Linearizability is a commonly accepted notion of correctness for libraries of concurrent algorithms, and recent years have seen a number of proposals of program logics for proving it. Although these logics differ in technical details, they embody similar reasoning principles. To explicate these principles, we propose a logic for proving linearizability that is generic: it can be instantiated with different means of compositional reasoning about concurrency, such as separation logic or rely-guarantee. To this end, we generalise the Views framework for reasoning about concurrency to handle relations between programs, required for proving linearizability. We present sample instantiations of our generic logic and show that it is powerful enough to handle concurrent algorithms with challenging features, such as helping.

The potential of branch length discrimination for branches containing six and more carbons via bulk NMR relaxation properties in the melt-state has been explored. A systematic increase in the 13 C spin-lattice relaxation time (T C 1 ) of the terminal branch carbons 1 and 2 was observed when the branch increased from 6 to 16 carbons in length. The measurement of T C 1 via inversion recovery at high-field showed the most reliable data. The effects of saturation and NOE were addressed by using recycle delays longer than 5 × T C 1 and the use of the saturation recovery was found to be unsatisfactory. All nuclear relaxation times were determined in a highly time efficient manner using a previously developed melt-state MAS NMR method.

This paper contributes to the development of techniques for the modular proof of programs that include concurrent algorithms. We present a proof of a non-blocking concurrent algorithm, which provides a shared stack. The inter-thread interference, which is essential to the algorithm, is confined in the proof and the specification to the modular operations, which perform push and pop on the stack. This is achieved by the mechanisms of separation logic. The effect is that inter-thread interference does not pollute specification or verification of clients of the stack.

We present a general theory of serializability, unifying a wide range of transactional algorithms, including some that are yet to come. To this end, we provide a compact semantics in which concurrent transactions PUSH their effects into the shared view (or UNPUSH to recall effects) and PULL the effects of potentially uncommitted concurrent transactions into their local view (or UNPULL to detangle). Each operation comes with simple criteria given in terms of commutativity (Lipton's left-movers and right-movers). The benefit of this model is that most of the elaborate reasoning (coinduction, simulation, subtle invariants, etc.) necessary for proving the serializability of a transactional algorithm is already proved within the semantic model. Thus, proving serializability (or opacity) amounts simply to mapping the algorithm on to our rules, and showing that it satisfies the rules' criteria.

Quantitative branch determination in polyolefins by melt-state NMR has been investigated paying particular attention to sensitivity per unit time. Comparison of spectra obtained using spectrometers operating at 700, 500 and 300 MHz 1 H Larmor frequency, with 4 and 7 mm MAS probeheads, showed that the best sensitivity was achieved at 500 MHz using a 7 mm 13 C- 1 H optimised high-temperature probehead. For materials available in large quantities static melt-state NMR, using large-diameter detection coils at 300 MHz, was shown to produce comparable results to melt-state MAS measurements in less time. Artificial line broadening, introduced by FID truncation, was reduced by the use of π pulse-train heteronuclear dipolar-decoupling. This decoupling method, when combined with a higher duty-cycle, allowed for the whole FID to be acquired. Optimised methods have been applied to the characterisation of short-chain branching (SCB) in polyethylene- and poly(propylene)-co-α-olefins with varying comonomer incorporation. Long-chain branch (LCB) concentrations of 8 branches per 100000 CH 2 were quantified for an industrial 'linear' polyethylene in 13 h, with a signal-to-noise ratio of 10 for the a branch site used. The use of J-coupling mediated polarisation transfer techniques were also shown to be viable for branch quantification in the melt-state.

One polyethylene and nine ethene/α-olefin copolymers differing in amount (0.4−2.9 mol %) and molar mass of the comonomer were characterized by NMR, SEC-MALLS, and rheology. Samples were polymerized using a [Ph2C(2,7-di-t-BuFlu)(Cp)]ZrCl2/MAO catalyst, with octene, octadecene, and hexacosene as comonomers, resulting in polymers of Mw ≈ 190 kg/mol. The comonomer content was determined by melt-state NMR. For the homopolymer 0.37 and 0.30 LCB/molecule were found by NMR and SEC-MALLS, respectively. Rheological quantities, such as the zero shear rate viscosity (η0), increased with LCB as compared to linear samples of the same Mw. The shape of the viscosity function and the linear steady-state elastic compliance ( ) showed a dependence on comonomer content and length. These findings are used to elucidate the various long-chain branching architectures. The highest comonomer content samples behaved like typical linear polymers in rheological experiments, while those with less comonomer contents were found to be lo...

The amygdaloid complex is one of the structures thought to modulate brain stimulation reward (BSR) elicited from the median forebrain bundle (MFB). Previous metabolic and behavioral data from our laboratory point to the amygdaloid cortical nuclei as key to this process. In this study, thresholds for rewarding stimulation of the MFB were determined for 42 days, 21 days following an electrolytic lesion to amygdaloid nuclei ipsilateral to the stimulation electrode, and 21 days following one applied to the contralateral amygdala. A subset of animals showed post-lesion changes in MFB frequency thresholds that were maintained if not augmented after the second lesion. These ranged from 26% to 150% compared to baseline values, among the largest ever reported to our knowledge. Interestingly, damage to anterior sites within the cortical nuclei was the most effective in producing modifications to the rewarding value of the stimulation. Equally singular was the finding that contralateral lesions tended to alter thresholds more than ipsilateral ones, confirming our earlier finding of interhemispheric connectivity in amygdaloid modulation of MFB reward signals. This interpretation was substantiated by tracking long-term metabolic activity in the amygdala using cytochrome oxidase histochemistry. The density of reaction product at damaged amygdala sites was negatively correlated (r=-0.90) with the increases in thresholds obtained at contralateral MFB loci. Together with the fact that such large lesion effects are seldom obtained, our metabolic results point to the existence of a relationship between these nuclei and reward signals generated at the MFB. Moreover, our data suggest that this communication takes place interhemispherically.

An effects system can be used to delimit the scope of computational effects within a program. This information is not only useful for the programmer, but also can be used in the definition of a number of optimizations. Most effects systems have been defined for functional languages with simple state. Greenhouse and Boyland have recently suggested how an effects system could be used within Java. In this paper we take a core imperative calculus for Java, and consider its extension with an effects system, following the suggestions of Greenhouse and Boyland. We define formally the effects system and an instrumented operational semantics and prove the correctness of the effects system; a question left open by Greenhouse and Boyland. We also consider the question of effect inference for our calculus, detailing an algorithm for inferring effects information and prove it correct.

In a concurrent setting, the usage protocol of standard separation logic specifications are not refinable by clients, because standard specifications abstract all information about potential interleavings. This breaks modularity, as libraries cannot be verified in isolation, since the appropriate specification depends on how clients intend to use the library. In this paper we propose a new logic and a new style of specification for thread-safe concurrent data structures. Our specifications allow clients to refine usage protocols and associate ownership of additional resources with instances of these data structures.

This paper introduces the tool SeLoger, which is a reasoner for satisfiability and entailment in a fragment of separation logic with pointers and linked lists. SeLoger builds upon and extends graph-based algorithms that have recently been introduced in order to settle both decision problems in polynomial time. Running SeLoger on standard benchmarks shows that the tool outperforms current state-of-the-art tools by orders of magnitude.

We present a case study of formal specification for the C$^\sharp$ joins library, an advanced concurrent library implemented using both shared mutable state and higher-order methods. The library is specified and verified in HOCAP, a higher-order separation logic extended with a higher-order variant of concurrent abstract predicates.

In this article we propose techniques based on separation logic to reason about object-oriented programs. This leads to a modular proof system that can deal with features considered core to object-oriented programming, including object encapsulation, subclassing, inheritance, and dynamic dispatch.

We present ribbon proofs, a diagrammatic system for proving program correctness based on separation logic. Ribbon proofs emphasise the structure of a proof, so are intelligible and pedagogical. Because they contain less redundancy than proof outlines, and allow each proof step to be checked locally, they may be more scalable. Where proof outlines are cumbersome to modify, ribbon proofs can be visually manoeuvred to yield proofs of variant programs. This paper introduces the ribbon proof system, proves its soundness and completeness, and outlines a prototype tool for validating the diagrams in Isabelle.

A key challenge for concurrent programming is that side-effects (memory operations) in one thread can affect the behavior of another thread. In this paper, we present a type system to restrict the updates to memory to prevent these unintended side-effects. We provide a novel combination of immutable and unique (isolated) types that ensures safe parallelism (race freedom and deterministic execution). The type system includes support for polymorphism over type qualifiers, and can easily create cycles of immutable objects. Key to the system's flexibility is the ability to recover immutable or externally unique references after violating uniqueness without any explicit alias tracking. Our type system models a prototype extension to C# that is in active use by a Microsoft team. We describe their experiences building large systems with this extension. We prove the soundness of the type system by an embedding into a program logic.

Separation logic is a concise method for specifying programs that manipulate dynamically allocated storage. Partially inspired by separation logic, Implicit Dynamic Frames has recently been proposed, aiming at first-order tool support. In this paper, we precisely connect the semantics of these two logics. We define a logic whose syntax subsumes both that of a standard separation logic, and that of implicit dynamic frames as sub-syntaxes. We define a total heap semantics for our logic, and, for the separation logic subsyntax, prove it equivalent the standard partial heaps model. In order to define a semantics which works uniformly for both subsyntaxes, we define the novel concept of a minimal state extension, which provides a different (but equivalent) definition of the semantics of separation logic implication and magic wand connectives, while also giving a suitable semantics for these connectives in implicit dynamic frames. We show that our resulting semantics agrees with the existing definition of weakest pre-condition semantics for the implicit dynamic frames fragment. Finally, we show that we can encode the separation logic fragment of our logic into the implicit dynamic frames fragment, preserving semantics. For the connectives typically supported by tools, this shows that separation logic can be faithfully encoded in a first-order automatic verification tool (Chalice)., Logical Methods in Computer Science, 8 (3), ISSN:1860-5974

The zirconium acetamidinate catalyst {Cp*Zr(Me)2[N(Et)C(Me)N(tBu)]} (Cp* = nj5-C5Me5) was used to synthesize both random and block copolymers based on 4-methyl-1-pentene (4M1P) and 1-pentene. The polymers have been characterized by NMR spectroscopy, SEC, DSC, high temperature HPLC and CRYSTAF. Unexpectedly, the yields and molecular weights decreased with increasing amounts of 1-pentene. The reason for this behavior is that 1-pentene occasionally undergoes 2,1-misinsertions trapping the catalyst in a dormant state. These 2,1-misinsertions do not seem to occur with the bulky 4M1P (branched a-olefin). Adding a small amount of ethylene reactivates the catalyst. Unlike most semi-crystalline polymers, the density of the crystalline phase of isotactic P4M1P can be lower than of the amorphous phase, when crystallized under very high pressures. To characterize this peculiar behavior of 4M1P-based polymers, various samples have been subjected to Pressure-Volume-Temperature (PVT) measurements. While the P4M1P homopolymers and block copolymers show the expected decrease in specific volume upon crystallization, the 4M1P-rich random copolymers proved not to vary in specific volume under the same conditions.

Corrigendum to “Random and block copolymers based on 4-methyl-1-pentene and 1-pentene” [Polymer 53 (2012) 3096e3106] Camille Descour , Tamara Meijer-Vissers , Tibor Macko , Matthew Parkinson , Dario Cavallo , Martin van Drongelen , Gerhard Hubner , Han Goossens , Robbert Duchateau a,* a Laboratory of Polymer Chemistry, Department of Chemical Engineering and Chemistry, Eindhoven University of Technology, P.O. Box 513, 5600 MB Eindhoven, The Netherlands b Laboratory of Polymer Technology, Department of Chemical Engineering and Chemistry, Eindhoven University of Technology, P.O. Box 513, 5600 MB Eindhoven, The Netherlands c Laboratory of Polymer Technology, Department of Mechanical Engineering, Eindhoven University of Technology, P.O. Box 513, 5600 MB Eindhoven, The Netherlands Department of Polymer Analysis Chemical Analytics, German Institute for Polymers, Schlossgartenstr. 6, 64289 Darmstadt, Germany Borealis Polyolefine GmbH, St. Peter-Strasse 25, 4021 Linz, Austria

Asynchronous memory operations provide a means for coping with the memory wall problem in multicore processors, and are available in many platforms and languages, e.g., the Cell Broadband Engine, CUDA and OpenCL. Reasoning about the correct usage of such operations involves complex analysis of memory accesses to check for races. We present a method and tool for proving memory-safety and race-freedom of multicore programs that use asynchronous memory operations. Our approach uses separation logic with permissions, and our tool automates this method, targeting a C-like core language. We describe our solutions to several challenges that arose in the course of this research. These include: syntactic reasoning about permissions and arrays, integration of numerical abstract domains, and utilization of an SMT solver. We demonstrate the feasibility of our approach experimentally by checking absence of DMA races on a set of programs drawn from the IBM Cell SDK. © 2011 IEEE.

jStar is a tool for automatically verifying Java programs. It uses separation logic to support abstract reasoning about object specifications. jStar can verify a number of challenging design patterns, including Subject/Observer, Visitor, Factory and Pooling. However, to use jStar one has to deal with a family of command-line tools that expect specifications in separate files and diagnose the errors by inspecting the text output from these tools. In this paper we present a plug-in, called jStar-eclipse, allowing programmers to use jStar from within Eclipse IDE. Our plug-in allows writing method contracts in Java source files in form of Java annotations. It automatically translates Java annotations into jStar specifications and propagates errors reported by jStar back to Eclipse, pinpointing the errors to the locations in source files. This way the plug-in ensures an overall better user experience when working with jStar. Our end goal is to make automated verification based on separation logic accessible to a broader audience.

Traditional transactional memory systems suffer from overly conservative conflict detection, yielding so-called false conflicts, because they are based on fine-grained, low-level read/write conflicts. In response, the recent trend has been toward integrating various abstract data-type libraries using ad-hoc methods of high-level conflict detection. These proposals have led to improved performance but a lack of a unified theory has led to confusion in the literature. We clarify these recent proposals by defining a generalization of transactional memory in which a transaction consists of course-grained (abstract data-type) operations rather than simply memory read/write operations. We provide semantics for both pessimistic (e.g. transactional boosting) and optimistic (e.g. traditional TMs and recent alternatives) execution. We show that both are included in the standard atomic semantics, yet find that the choice imposes different requirements on the coarse-grained operations: pessimistic requires operations be left-movers, optimistic requires right-movers. Finally, we discuss how the semantics applies to numerous TM implementation details discussed widely in the literature.

A novel self-supported emulsion-based catalyst and a conventional MgCl2-supported Ziegler–Natta catalyst were used in the copolymerization of propylene and ethylene under industrial conditions using triethyl aluminium as cocatalyst and dicyclopentyl dimethoxy silane as external donor. The effects of the concentration of ethylene and hydrogen on the polymerization behaviors and polymer properties were investigated. The combined effect of both ethylene and hydrogen increased the relative activity of the novel catalyst more than for the conventional catalyst. This trend was consistent with our earlier observed higher degree of dormancy, due to 2,1 insertions, found with the novel catalyst. More importantly, the work has uncovered that the self-supported catalyst incorporates ethylene in a more random fashion and produces copolymers with relatively narrow molecular weight distribution (MWD). These results in combination with polymer microstructure studies using Fourier transform infrared spectroscopy, 13C-NMR spectroscopy, and differential scanning calorimetry all indicated that the novel catalyst has a narrower distribution of active site types than the conventional reference catalyst. The narrow composition of active site structures, the narrow MWD, and the random incorporation of ethylene into the polymer chain indicated that the emulsion-based catalyst possesses features that to a certain degree tend to be more indicative for a single-site-like catalyst structure and behavior. © 2011 Wiley Periodicals, Inc. J Appl Polym Sci, 2011

Traditional transactional memory systems suffer from overly conservative conflict detection, yielding so-called false conflicts, because they are based on fine-grained, low-level read/write conflicts. In response, the recent trend has been toward integrating various abstract data-type libraries using ad-hoc methods of high-level conflict detection. These proposals have led to improved performance but a lack of a unified theory has led to confusion in the literature.We clarify these recent proposals by defining a generalization of transactional memory in which a transaction consists of coarse-grained (abstract data-type) operations rather than simple memory read/write operations. We provide semantics for both pessimistic (e.g. transactional boosting) and optimistic (e.g. traditional TMs and recent alternatives) execution. We show that both are included in the standard atomic semantics, yet find that the choice imposes different requirements on the coarse-grained operations: pessimistic requires operations be left-movers, optimistic requires right-movers. Finally, we discuss how the semantics applies to numerous TM implementation details discussed widely in the literature.