Search

Despite recent breakthroughs in understanding how protein sequence relates to structure and function, considerably less attention has been paid to the general features of protein surfaces beyond those regions involved in binding and catalysis. This paper provides a systematic survey of the universe of protein surfaces and quantifies the sizes, shapes, and curvatures of the positively/negatively charged and hydrophobic/hydrophilic surface patches as well as correlations between such patches. It then compares these statistics with the metrics characterizing nanoparticles functionalized with ligands terminated with positively and negatively charged ligands. These particles are of particular interest because they are also surface-patchy and have been shown to exhibit both antibiotic and anticancer activities - via selective interactions against various cellular structures - prompting loose analogies to proteins. Our analyses support such analogies in several respects (e.g., patterns of charged protrusions and hydrophobic niches similar to those observed in proteins), although there are also significant differences. Looking forward, this work provides a blueprint for the rational design of synthetic nanoobjects with further enhanced mimicry of proteins' surface properties.

This report summarizes the discussions and conclusions of a 2-day multidisciplinary workshop that brought together researchers and practitioners in healthcare, computer science, and social sciences to explore what lessons were learned and what actions, primarily in research, could be taken. One consistent observation was that there is significant merit in thinking not only about pandemic situations, but also about peacetime advances, as many healthcare networks and communities are now in a perpetual state of crisis. Attendees discussed how the COVID-19 pandemic amplified gaps in our health and computing systems, and how current and future computing technologies could fill these gaps and improve the trajectory of the next pandemic. Three major computing themes emerged from the workshop: models, data, and infrastructure. Computational models are extremely important during pandemics, from anticipating supply needs of hospitals, to determining the care capacity of hospital and social service providers, to projecting the spread of the disease. Accurate, reliable models can save lives, and inform community leaders on policy decisions. Health system users require accurate, reliable data to achieve success when applying models. This requires data and measurement standardization across health care organizations, modernizing the data infrastructure, and methods for ensuring data remains private while shared for model development, validation, and application. Finally, many health care systems lack the data, compute, and communication infrastructures required to build models on their data, use those models in ordinary operations, or even to reliably access their data. Robust and timely computing research has the potential to better support healthcare works to save lives in times of crisis (e.g., pandemics) and today during relative peacetime.

Languages with gradual information-flow control combine static and dynamic techniques to prevent security leaks. Gradual languages should satisfy the gradual guarantee: programs that only differ in the precision of their type annotations should behave the same modulo cast errors. Unfortunately, Toro et al. [2018] identify a tension between the gradual guarantee and information security; they were unable to satisfy both properties in the language $\mathrm{GSL}_\mathsf{Ref}$ and had to settle for only satisfying information-flow security. Azevedo de Amorim et al. [2020] show that by sacrificing type-guided classification, one obtains a language that satisfies both noninterference and the gradual guarantee. Bichhawat et al. [2021] show that both properties can be satisfied by sacrificing the no-sensitive-upgrade mechanism, replacing it with a static analysis. In this paper we present a language design, $\lambda_{\mathtt{IFC}}^\star$, that satisfies both noninterference and the gradual guarantee without making any sacrifices. We keep the type-guided classification of $\mathrm{GSL}_\mathsf{Ref}$ and use the standard no-sensitive-upgrade mechanism to prevent implicit flows through mutable references. The key to the design of $\lambda_{\mathtt{IFC}}^\star$ is to walk back the decision in $\mathrm{GSL}_\mathsf{Ref}$ to include the unknown label $\star$ among the runtime security labels. We give a formal definition of $\lambda_{\mathtt{IFC}}^\star$, prove the gradual guarantee, and prove noninterference. Of technical note, the semantics of $\lambda_{\mathtt{IFC}}^\star$ is the first gradual information-flow control language to be specified using coercion calculi (a la Henglein), thereby expanding the coercion-based theory of gradual typing., Comment: 48 pages, 24 figures

We derived position-velocity density distribution diagrams along the major (PA = 77$^{\circ}$) axis of the elliptical planetary nebula NGC 7009 with the Keck HIRES [SII] 6716/6731 \A, doublet spectral images. The average densities of the main shell and knots of NGC 7009 derived from the [SII] 6716/673 \A, fluxes integrated over the line of sight indicate a density range of $N_{\rm e}$ = $10^{3.4}$ to 10$^{3.9}$ $cm^{-3}$, while the local densities from the volume fraction resolved in radial velocities along the line of sight show a considerably large range of about 10$^{2.8}$ -- 10$^{4.7}$ $cm^{-3}$. The derived projection angle of the major axis of the main shell is about $\psi \sim$18.3($\pm$2)$^{\circ}$. Assuming that the main shell is an ellipsoidal shell with $a \simeq$16$''$ and $b \simeq 6''$, we found the range of expansion velocity, radius, and latitude of four knots and a hot bubble. The four knots at the points in symmetrical positions are roughly aligned with the same axis of expansion of latitudes $\phi \sim \pm 34.5(\pm 0.6)^{\circ}$: One pair expands at about 35 $kms^{-1}$ close to the main ellipsoidal shell, and the other expands rapidly at about 60 $kms^{-1}$ at a distance of $r \sim 16''$. In the latitude range $\phi = $65 -- 75$^{\circ}$, the hot bubble of a relatively large structure expands rapidly with a velocity of 130 -- 150 $kms^{-1}$. Four knots and hot bubble points that expand faster than the main shell appear to have been formed by two to three eruptions at a different epoch than the primary structure formation., Comment: 18 pages, 7 figures Accepted for publication in ApJS

This paper presents the first machine-checked proof of noninterference for a language with gradual information-flow control, thereby establishing a rock solid foundation for secure programming languages that give programmers the choice between runtime versus compile-time enforcement. Along the way we uncovered a flaw in one of the noninterference proofs in the literature, and give a counterexample for one of the main lemmas. The particular language studied in this paper, $\lambda_{\mathtt{SEC}}^\star$, is based on the GLIO language of Azevedo de Amorim et al. [2020]. To make the design more accessible to other researchers, this paper contributes the first traditional semantics for the language, that is, we define compilation from $\lambda_{\mathtt{SEC}}^\star$ to a cast calculus and design a reduction semantics for the latter that includes blame tracking. In addition to the proof of noninterference, we also mechanize proofs of type safety, determinism, and that compilation preserves types., Comment: 32 pages, 18 figures

We analyzed the minor axis spectra of the elliptical planetary nebula (PN) NGC 7009 observed with the Keck HIRES with a 0.862$"$ $\times$ 10$"$ slit placed at about $\sim$7.5$"$ and 10$"$ away from the center and a 0.862$"$ $\times$ 14$"$ slit at the center. The mean densities derived from the integrated [SII] 6716/6731\r{A}, fluxes along the Keck HIRES slit length indicate a density range of 10$^{3.7}$ to 10$^{4.1}$ cm$^{-3}$, while the local densities derived from the slit spectral images show a large local density variation of about 10$^{2.8}$ - 10$^{4.6}$ cm$^{-3}$: local densities vary substantially more than values integrated over the line of sight. The expansion rates of the main and outer shells obtained by [SII] are about 21.7 and 30.0 kms$^{-1}$, respectively. The kinematic results of the [SII] spectral lines correspond to the outermost regions of the two shells and are not representative of the whole PN but are closely related to the other emission lines observed in the shell gas. We conclude that the density contrast leads to the formation of the inner shell, while the change in ionization state leads to the formation of the outer shell. We suggest that the inner main and outer shells result from two successive major ejections. The physical conditions of the central star must have been different when these shells first formed., Comment: 15 pages, 9 figures, accepted for publication in ApJ

The Userfault Object (UFO) framework explores avenues of cooperating with the operating system to use memory in non-traditional ways. We implement a framework that employs the Linux kernel's userfault mechanism to fill the contents of runtime objects on demand. When an object's memory is accessed the framework executes a user-defined function that generates a slice of the object. The back-end can generate data from thin air, calculate it from a formula, or retrieve it from persistent storage, the network, or other sources (with or without post-processing). UFOs follow the memory layout of standard runtime objects, so they can be introspected and written to safely. The framework manages the loading and unloading of object segments to ensure that memory is reclaimed as needed and data is never lost. This allows the UFO framework to implement larger-than-memory data structures that never materialize into memory in full. Implementing objects as UFOs also impacts performance, since overhead of populating memory is amortized by loading entire pages of data at a time. The host runtime can also rely on direct memory accesses into userfault object obviating the need for a special dispatch mechanism. We provide a proof-of-concept implementation of the UFO framework for the R language., Comment: In Proceedings of ICOOLPS '21: Workshop on Implementation, Compilation, Optimization of OO Languages, Programs and Systems (ICOOOLPS '21). UFOs repository: https://github.com/PRL-PRG/ufos

Technology has the opportunity to assist older adults as they age in place, coordinate caregiving resources, and meet unmet needs through access to resources. Currently, older adults use consumer technologies to support everyday life, however these technologies are not always accessible or as useful as they can be. Indeed, industry has attempted to create smart home technologies with older adults as a target user group, however these solutions are often more focused on the technical aspects and are short lived. In this paper, we advocate for older adults being involved in the design process - from initial ideation to product development to deployment. We encourage federally funded researchers and industry to create compensated, diverse older adult advisory boards to address stereotypes about aging while ensuring their needs are considered. We envision artificial intelligence systems that augment resources instead of replacing them - especially in under-resourced communities. Older adults rely on their caregiver networks and community organizations for social, emotional, and physical support; thus, AI should be used to coordinate resources better and lower the burden of connecting with these resources. Although sociotechnical smart systems can help identify needs of older adults, the lack of affordable research infrastructure and translation of findings into consumer technology perpetuates inequities in designing for diverse older adults. In addition, there is a disconnect between the creation of smart sensing systems and creating understandable, actionable data for older adults and caregivers to utilize. We ultimately advocate for a well-coordinated research effort across the United States that connects older adults, caregivers, community organizations, and researchers together to catalyze innovative and practical research for all stakeholders., Comment: A Computing Community Consortium (CCC) white paper, 6 pages

We are entering a new "data everywhere-anytime" era that pivots us from being tracked online to continuous tracking as we move through our everyday lives. We have smart devices in our homes, on our bodies, and around our communities that collect data that is used to guide decisions that have a major impact on our lives - from loans to job interviews and judicial rulings to health care interventions. We create a lot of data, but who owns that data? How is it shared? How will it be used? While the average person does not have a good understanding of how the data is being used, they know that it carries risks for them and society. Although some people may believe they own their data, in reality, the problem of understanding the myriad ways in which data is collected, shared, and used, and the consequences of these uses is so complex that only a few people want to manage their data themselves. Furthermore, much of the value in the data cannot be extracted by individuals alone, as it lies in the connections and insights garnered from (1) one's own personal data (is your fitness improving? Is your home more energy efficient than the average home of this size?) and (2) one's relationship with larger groups (demographic group voting blocks; friend network influence on purchasing). But sometimes these insights have unintended consequences for the person generating the data, especially in terms of loss of privacy, unfairness, inappropriate inferences, information bias, manipulation, and discrimination. There are also societal impacts, such as effects on speech freedoms, political manipulation, and amplified harms to weakened and underrepresented communities. To this end, we look at major questions that policymakers should ask and things to consider when addressing these data ownership concerns., Comment: A Computing Community Consortium (CCC) white paper, 6 pages

We analyze high dispersion emission lines of the symbiotic nova AG Peg, observed in 1998, 2001, and 2002. The H$\alpha$ and H$\beta$ lines show three components, two narrow and one underlying broad line components, but most other lines, such as HI, HeI, and HeII lines, show two blue- and red-shifted components only. A recent study by Lee & Hyung (2018) suggested that the double Gaussian lines emitted from a bipolar conic shell is likely to form Raman scattering lines observed in 1998. In this study, we show that the bipolar cone with an opening angle of 74$^{o}$, which expands at a velocity of 70 kms$^{-1}$ along the polar axis of the white dwarf, can accommodate the observed double line profiles in 1998, 2001, and 2002. We conclude that the emission zone of the bipolar conic shell, which formed along the bipolar axis of the white dwarf due to the collimation by the accretion disk, is responsible for the double Gaussian profiles., Comment: 9 pages, 9 figures, and 4 tables

The research on gradual typing has led to many variations on the Gradually Typed Lambda Calculus (GTLC) of Siek and Taha (2006) and its underlying cast calculus. For example, Wadler and Findler (2009) added blame tracking, Siek et al. (2009) investigated alternate cast evaluation strategies, and Herman et al. (2010) replaced casts with coercions for space-efficiency. The meta-theory for the GTLC has also expanded beyond type safety to include blame safety (Tobin-Hochstadt and Felleisen 2006), space consumption (Herman et al. 2010), and the gradual guarantees (Siek et al. 2015). These results have been proven for some variations of the GTLC but not others. Furthermore, researchers continue to develop variations on the GTLC but establishing all of the meta-theory for new variations is time consuming. This article identifies abstractions that capture similarities between many cast calculi in the form of two parameterized cast calculi, one for the purposes of language specification and the other to guide space-efficient implementations. The article then develops reusable meta-theory for these two calculi, proving type safety, blame safety, the gradual guarantees, and space consumption. Finally, the article instantiates this meta-theory for eight cast calculi including five from the literature and three new calculi. All of these definitions and theorems, including the two parameterized calculi, the reusable meta-theory, and the eight instantiations, are mechanized in Agda making extensive use of module parameters and dependent records to define the abstractions., Comment: In submission to Journal of Functional Programming

We performed detailed spectroscopic analyses of a young C-rich planetary nebula (PN) Jonckheere900 (J900) in order to characterise the properties of the central star and nebula. Of the derived 17 elemental abundances, we present the first determination of eight elemental abundances. We present the first detection of the [F IV] 4059.9 A, [F V] 13.4 um, and [Rb IV] 5759.6 A lines in J900. J900 exhibits a large enhancement of F and neutron-capture elements Se, Kr, Rb, and Xe. We investigated the physical conditions of the H2 zone using the newly detected mid-IR H2 lines while also using the the previously measured near-IR H2 lines, which indicate warm (~670 K) and hot (~3200 K) temperature regions. We built the spectral energy distribution (SED) model to be consistent with all the observed quantities. We found that about 67 % of all dust and gas components (4.5x10^-4 Msun and 0.83 Msun, respectively) exists beyond the ionisation front, indicating critical importance of photodissociation regions in understanding stellar mass loss. The best-fitting SED model indicates that the progenitor evolved from an initially ~2.0 Msun star which had been in the course of the He-burning shell phase. Indeed, the derived elemental abundance pattern is consistent with that predicted by a asymptotic giant branch star nucleosynthesis model for a 2.0 Msun star with Z = 0.003 and partial mixing zone mass of 6.0x10^-3 Msun. Our study demonstrates how accurately determined abundances of C/F/Ne/neutron-capture elements and gas/dust masses help us understand the origin and the internal evolution of the PN progenitors., Comment: 22 pages, 11 figures, accepted for publication by MNRAS. The title is corrected for accordance with the paper published by MNRAS

The implicit and explicit biases built into our computing systems are becoming increasingly clear -- they impact everything from targeting of advertisements to how we are identified as people. These biases disproportionately affect marginalized groups -- people who are excluded from mainstream social, economic, cultural, or political life -- more acutely. While these biases can affect all aspects of our lives, from leisure to criminal justice to personal finances, they are all the more critical in the context of health and healthcare due to their significant personal and societal implications. In this interdisciplinary workshop, we explored how to design and build health systems for diverse populations through the following disciplinary lenses. The Computing Community Consortium (CCC) sponsored a two-day workshop titled Sociotechnical Interventions for Health Disparity Reduction in collaboration with the leadership of the Society for Behavioral Medicine's (SBM) 39th Annual Meeting on Monday, April 9 and Tuesday, April 10, 2018 in New Orleans, Louisiana. The workshop's goal was to bring together leading researchers in computing, health informatics, behavioral medicine, and health disparities to develop an integrative research agenda focused on sociotechnical interventions to reduce health disparities and improve the health of marginalized populations., Comment: A Computing Community Consortium (CCC) workshop report, 30 pages

The subtyping rules for intersection types traditionally employ a transitivity rule (Barendregt et al. 1983), which means that subtyping does not satisfy the subformula property, making it more difficult to use in filter models for compiler verification. Laurent develops a sequent-style subtyping system, without transitivity, and proves transitivity via a sequence of six lemmas that culminate in cut-elimination (2018). This article develops a subtyping system in regular style that omits transitivity and provides a direct proof of transitivity, significantly reducing the length of the proof, exchanging the six lemmas for just one. Inspired by Laurent's system, the rule for function types is essentially the $\beta$-soundness property. The new system satisfies the "subformula conjunction property": every type occurring in the derivation of $A <: B$ is a subformula of $A$ or $B$, or an intersection of such subformulas. The article proves that the new subtyping system is equivalent to that of Barendregt, Coppo, and Dezani-Ciancaglini., Comment: 18 pages

Gradual typing enables programmers to combine static and dynamic typing in the same language. However, ensuring a sound interaction between the static and dynamic parts can incur significant runtime cost. In this paper, we perform a detailed performance analysis of the transient gradual typing approach implemented in Reticulated Python, a gradually typed variant of Python. The transient approach inserts lightweight checks throughout a program rather than installing proxies on higher order values. We show that, when running Reticulated Python and the transient approach on CPython, performance decreases as programs evolve from dynamic to static types, up to a 6x slowdown compared to equivalent Python programs. To reduce this overhead, we design a static analysis and optimization that removes redundant runtime checks. The optimization employs a static type inference algorithm that solves traditional subtyping constraints and also a new kind of check constraint. We evaluate the resulting performance and find that for many programs, the efficiency of partially typed programs is close to their untyped counterparts, removing most of the slowdown of transient checks. Finally, we measure the efficiency of Reticulated Python programs when running on PyPy, a tracing JIT. We find that combining PyPy with our type inference algorithm reduces the overall overhead to zero.

Gradual typing combines static and dynamic typing in the same program. One would hope that the performance in a gradually typed language would range between that of a dynamically typed language and a statically typed language. Existing implementations of gradually typed languages have not achieved this goal due to overheads associated with runtime casts. Takikawa et al. (2016) report up to 100$\times$ slowdowns for partially typed programs. In this paper we present a compiler, named Grift, for evaluating implementation techniques for gradual typing. We take a straightforward but surprisingly unexplored implementation approach for gradual typing, that is, ahead-of-time compilation to native assembly code with carefully chosen runtime representations and space-efficient coercions. Our experiments show that this approach achieves performance on par with OCaml on statically typed programs and performance between that of Gambit and Racket on untyped programs. On partially typed code, the geometric mean ranges from 0.42$\times$ to 2.36$\times$ that of (untyped) Racket across the benchmarks. We implement casts using the coercions of Siek, Thiemann, and Wadler (2015). This technique eliminates all catastrophic slowdowns without introducing significant overhead. Across the benchmarks, coercions range from 15% slower (fft) to almost 2$\times$ faster (matmult) than regular casts. We also implement the monotonic references of Siek et al. (2015). Monotonic references eliminate all overhead in statically typed code, and for partially typed code, they are faster than proxied references, sometimes up to 1.48$\times$.

The H$\alpha$ and H$\beta$ line profiles of the symbiotic star AG Peg observed on 1998 September (phase $\phi$ = 10.24), display the top narrow double Gaussian and bottom broad (FWHM of 200 -- 400 kms$^{-1}$) components. The photo-ionization model indicated that the ionized zone, responsible for the hydrogen Balmer and Lyman lines, is radiation-bounded, with a hydrogen gas number density of $n_{\rm H} \sim 10^{9.85}$ cm$^{-3}$ and a gas temperature of T$_e$ = 12\,000 -- 15\,000~K. We carried out Monte Carlo simulations to fit the Raman scattering broad wings, assuming that the hydrogen Ly$\beta$ and Ly$\gamma$ lines emitted within the radiation-bounded HII zone around a white dwarf have the same double Gaussian line profile shape as the hydrogen Balmer lines. The simulation shows that the scattering HI zones are attached to (or located just outside of) the inner HII shells. The best fit to the observed broad HI line profiles indicates that the column density of the scattering neutral zone is $N_{\rm H} \simeq $ 3 -- 5 $\times$ 10$^{19}$ cm$^{-2}$. We examined whether the geometrical structure responsible for the observed H$\alpha$ and H$\beta$ line profiles is a bipolar conical shell structure, consisting of the radiation-bounded ionized zone and the outer material bounded neutral zone. The expanding bipolar structure might be two opposite regions of the common envelope or the outer shell of the Roche lobe around the hot white dwarf, formed through the mass inflows from the giant star and pushed out by the fast winds from the hot white dwarf., Comment: 13pages, 8 figures, Accepted for publication in the main journal of MNRAS

Operational semantics have been enormously successful, in large part due to its flexibility and simplicity, but they are not compositional. Denotational semantics, on the other hand, are compositional but the lattice-theoretic models are complex and difficult to scale to large languages. However, there are elementary models of the $\lambda$-calculus that are much less complex: by Coppo, Dezani-Ciancaglini, and Salle (1979), Engeler (1981), and Plotkin (1993). This paper takes first steps toward answering the question: can elementary models be good for the day-to-day work of language specification, mechanization, and compiler correctness? The elementary models in the literature are simple, but they are not as intuitive as they could be. To remedy this, we create a new model that represents functions literally as finite graphs. Regarding mechanization, we give the first machine-checked proof of soundness and completeness of an elementary model with respect to an operational semantics. Regarding compiler correctness, we define a polyvariant inliner for the call-by-value $\lambda$-calculus and prove that its output is contextually equivalent to its input. Toward scaling elementary models to larger languages, we formulate our semantics in a monadic style, give a semantics for System F with general recursion, and mechanize the proof of type soundness., Comment: 25 pages, revision of POPL 2018 submission, now under submission to ESOP 2018

Type soundness is an important property of modern programming languages. In this paper we explore the idea that "well-typed languages are sound": the idea that the appropriate typing discipline over language specifications guarantees that the language is type sound. We instantiate this idea for a certain class of languages defined using small step operational semantics by ensuring the progress and preservation theorems. Our first contribution is a syntactic discipline for organizing and restricting language specifications so that they automatically satisfy the progress theorem. This discipline is not novel but makes explicit the way expert language designers have been organizing a certain class of languages for long time. We give a formal account of this discipline by representing language specifications as (higher-order) logic programs and by giving a meta type system over that collection of formulas. Our second contribution is a methodology and meta type system for guaranteeing that languages satisfy the preservation theorem. Ultimately, we proved that language specifications that conform to our meta type systems are guaranteed to be type sound. We have implemented these ideas in the TypeSoundnessCertifier, a tool that takes language specifications in the form of logic programs and type checks them according to our meta type systems. For those languages that pass our type checker, our tool automatically produces a proof of type soundness that can be machine-checked by the Abella proof assistant. For those languages that fail our type checker, the tool pinpoints the design mistakes that hinder type soundness. We have applied the TypeSoundnessCertifier to a large number of programming languages, including those with recursive types, polymorphism, letrec, exceptions, lists and other common types and operators.

Gradual typing combines static and dynamic typing in the same language, offering the benefits of both to programmers. Static typing provides error detection and strong guarantees while dynamic typing enables rapid prototyping and flexible programming idioms. For programmers to fully take advantage of a gradual type system, however, they must be able to trust their type annotations, and so runtime checks must be performed at the boundaries of static and dynamic code to ensure that static types are respected. Higher order and mutable values cannot be completely checked at these boundaries, and so additional checks must be performed at their use sites. Traditionally, this has been achieved by installing wrappers or proxies on such values that moderate the flow of data between static and dynamic, but these can cause problems if the language supports comparison of object identity or has a foreign function interface. Reticulated Python is a gradually typed variant of Python implemented via a source-to-source translator for Python 3. It implements a proxy-free alternative design named transient casts. This paper presents a formal semantics for transient casts and shows that not only are they sound, but they work in an open-world setting in which the Reticulated translator has only been applied to some of the program; the rest is untranslated Python. We formalize this open world soundness property and use Coq to prove that it holds for Anthill Python, a calculus that models Reticulated Python.

We simulate shock-free and shocked viscous accretion flow onto a black hole in a two dimensional cylindrical geometry, where initial conditions were chosen from analytical solutions. The simulation code used the Lagrangian Total Variation Diminishing (LTVD) and remap routine, which enabled us to attain high accuracy in capturing shocks and to handle the angular momentum distribution correctly. Inviscid shock-free accretion disk solution produced a thick disk structure, while the viscous shock-free solution attained a Bondi-like structure, but in either case, no jet activity nor any QPO-like activity developed. The steady state shocked solution in the inviscid, as well as, in the viscous regime, matched theoretical predictions well. However, increasing viscosity renders the accretion shock unstable. Large amplitude shock oscillation is accompanied by intermittent, transient inner multiple shocks. Such oscillation of the inner part of disk is interpreted as the source of QPO in hard X-rays observed in micro-quasars. Strong shock oscillation induces strong episodic jet emission. The jets also showed existence of shocks, which are produced as one shell hits the preceding one. The periodicity of jets and shock oscillation were similar. The jets for higher viscosity parameter are evidently stronger and faster., Comment: 24pages, 18figures. Accepted for publication in the Astrophysical Journal

Distributed Transactional Memory (DTM) is an emerging approach to distributed synchronization based on the application of the transaction abstraction to distributed computation. DTM comes in several system models, but the control flow model (CF) is particularly powerful, since it allows transactions to delegate computation to remote nodes as well as access shared data. However, there are no existing CF DTM systems that perform on par with state-of-the-art systems operating in other models. Hence, we introduce a CF DTM synchronization algorithm, OptSVA-CF. It supports fine-grained pessimistic concurrency control, so it avoids aborts, and thus avoids problems with irrevocable operations. Furthermore, it uses early release and asynchrony to parallelize concurrent transactions to a high degree, while retaining strong safety properties. We implement it as Atomic RMI 2, in effect producing a CF DTM system that, as our evaluation shows, can outperform a state-of-the-art non-CF DTM such as HyFlow2.

Transactional Memory (TM) is an approach aiming to simplify concurrent programming by automating synchronization while maintaining efficiency. TM usually employs the optimistic concurrency control approach, which relies on transactions aborting and restarting if conflicts occur. However, an aborted transaction can still leave some effects in the system that cannot be cleaned up, if irrevocable operations are present within its code. The pessimistic approach eliminates that problem, since it relies on deferring operations in case of conflict rather than aborting, but hitherto pessimistic TMs suffered from low parallelism due to the need of serializing transactions. In this paper, we aim to introduce OptSVA, a pessimistic TM concurrency control algorithm that ensures a high level of parallelism through a battery of far-reaching optimizations including early release, asynchronous execution, and the extensive use of buffering.

Transactional Memory (TM) is an approach to concurrency control that aims to make writing parallel programs both effective and simple. The approach is started in non-distributed multiprocessor systems, but is gaining popularity in distributed systems to synchronize tasks at large scales. Efficiency and scalability are often the key issues in TM research, so performance benchmarks are an important part of it. However, while standard TM benchmarks like the STAMP suite and STMBench7 are available and widely accepted, they do not translate well into distributed systems. Hence, the set of benchmarks usable with distributed TM systems is very limited, and must be padded with microbenchmarks, whose simplicity and artificial nature often makes them uninformative or misleading. Therefore, this paper introduces Helenos, a realistic, complex, and comprehensive distributed TM benchmark based on the problem of the Facebook inbox, an application of the Cassandra distributed store.

Transaction Memory (TM) is a concurrency control abstraction that allows the programmer to specify blocks of code to be executed atomically as transactions. However, since transactional code can contain just about any operation attention must be paid to the state of shared variables at any given time. E.g., contrary to a database transaction, if a TM transaction reads a stale value it may execute dangerous operations, like attempt to divide by zero, access an illegal memory address, or enter an infinite loop. Thus serializability is insufficient, and stronger safety properties are required in TM, which regulate what values can be read, even by transactions that abort. Hence, a number of TM safety properties were developed, including opacity, and TMS1 and TMS2. However, such strong properties preclude using early release as a technique for optimizing TM, because they virtually forbid reading from live transactions. On the other hand, properties that do allow early release are either not strong enough to prevent any of the problems mentioned above (recoverability), or add additional conditions on transactions with early release that limit their applicability (elastic opacity, live opacity, virtual world consistency). This paper introduces last-use opacity, a new TM safety property that is meant to be a compromise between strong properties like opacity and serializability. The property eliminates all but a small class of inconsistent views and poses no stringent conditions on transactions. For illustration, we present a last-use opaque TM algorithm and show that it satisfies the new safety property.