A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools

Today's complex software systems combine high-level concurrency models. Each model is used to solve a specific set of problems. Unfortunately, debuggers support only the low-level notions of threads and shared memory, forcing developers to reason about these notions instead of the high-level concurrency models they chose. This paper proposes a concurrency-agnostic debugger protocol that decouples the debugger from the concurrency models employed by the target application. As a result, the underlying language runtime can define custom breakpoints, stepping operations, and execution events for each concurrency model it supports, and a debugger can expose them without having to be specifically adapted. We evaluated the generality of the protocol by applying it to SOMns, a Newspeak implementation, which supports a diversity of concurrency models including communicating sequential processes, communicating event loops, threads and locks, fork/join parallelism, and software transactional memory. We implemented 21 breakpoints and 20 stepping operations for these concurrency models. For none of these, the debugger needed to be changed. Furthermore, we visualize all concurrent interactions independently of a specific concurrency model. To show that tooling for a specific concurrency model is possible, we visualize actor turns and message sends separately.Comment: International Symposium on Dynamic Language

Array bounds check elimination in the context of deoptimization

AbstractWhenever an array element is accessed, Java virtual machines execute a compare instruction to ensure that the index value is within the valid bounds. This reduces the execution speed of Java programs. Array bounds check elimination identifies situations in which such checks are redundant and can be removed. We present an array bounds check elimination algorithm for the Java HotSpot™ VM based on static analysis in the just-in-time compiler.The algorithm works on an intermediate representation in static single assignment form and maintains conditions for index expressions. It fully removes bounds checks if it can be proven that they never fail. Whenever possible, it moves bounds checks out of loops. The static number of checks remains the same, but a check inside a loop is likely to be executed more often. If such a check fails, the executing program falls back to interpreted mode, avoiding the problem that an exception is thrown at the wrong place.The evaluation shows a speedup near to the theoretical maximum for the scientific SciMark benchmark suite and also significant improvements for some Java Grande benchmarks. The algorithm slightly increases the execution speed for the SPECjvm98 benchmark suite. The evaluation of the DaCapo benchmarks shows that array bounds checks do not have a significant impact on the performance of object-oriented applications

Debugging Native Extensions of Dynamic Languages

Many dynamic programming languages such as Ruby and Python enable developers to use so called native extensions, code implemented in typically statically compiled languages like C and C++. However, debuggers for these dynamic languages usually lack support for also debugging these native extensions. GraalVM can execute programs implemented in various dynamic programming languages and, by using the LLVM-IR interpreter Sulong, also their native extensions. We added support for source-level debugging to Sulong based on GraalVM's debugging framework by associating run-time debug information from the LLVM-IR level to the original program code. As a result, developers can now use GraalVM to debug source code written in multiple LLVM-based programming languages as well as programs implemented in various dynamic languages that invoke it in a common debugger front-end.Comment: 7 pages, 7 figures, accepted at 15th International Conference on Managed Languages & Runtimes (ManLang'18

A Story in Brown and White Regulation of Metabolic Homeostasis by Brown Adipose tissue

Adipose tissue exists in three shades: White adipose tissue (WAT), the site of energy storage, brown adipose tissue (BAT), which burns nutrients to generate heat and maintain body temperature, and brown in white adipose tissue (brite AT), which represents WAT adapting BAT features in cold exposure. Thermogenically active BAT has been discovered in adult humans and inversely correlates with obesity and insulin resistance. The link between impaired insulin sensitivity and the browning of adipose tissue has not been clear however. While the necessity for insulin for normal development of adipose tissues is well recognised, the dependence of the recruitment of brite adipocytes in functional insulin signalling has not been investigated before. We show that β3-adrenergic stimulation can overcome insulin deficiency and fully activate the brown program in WAT. Vice versa, while it is known that the presence of brite AT allows enhanced glucose clearance, it has not previously been investigated whether this tissue is more insulin sensitive than white. Surprisingly we found that brite cells and tissues demonstrated markedly elevated glucose uptake even in the absence of insulin, and while insulin augmented glucose uptake to both white and brite AT, the degree of this response did not differ between the two types of adipose tissue. In line with these findings, we observed a marked induction of the insulin independent glucose transporter solute carrier family 2 (GLUT-1) upon browning of WAT. Thus we demonstrate for the first time that insulin signalling is dispensable for brite recruitment and not improved in browned cells or tissues. The nuclear receptor co-regulator Transducin (beta)-like 1 X-linked receptor 1 (TBLR) is a known transcriptional master-regulator that carries out distinct metabolic roles in liver and WAT. We show that, being part of the machinery of a general regulatory mechanism, the actions of TBLR depend largely on its environment, since TBLR deficiency in BAT lead to a distinct phenotype compared to other tissues and its role in mature cells differs from its role during adipogenic differentiation. During differentiation, TBLR balanced growth versus differentiation cues and its depletion reduced glucose import and metabolic activity of mature adipocytes. In thermogenically active mature brown adipocytes or BAT, Tblr expression was found to be cold-inducible downstream of the MAPK pathway. BAT-specific knock out of TBLR could be largely compensated for, since gene expression, adiposity, lipid or glucose handling and respiration in these mice (BATKO mice) were normal. However, BATKO mice had impaired maximal thermogenic capacity upon acute β3-adrenergic stimulation. Surprisingly, BAT-specific TBLR KO had systemic effects on gene expression and lead to reduced serum very low density lipoprotein (VLDL) both in the cold and at thermoneutrality. After excluding altered hepatic production or loss to feces, we observed elevated lipid deposition to WAT. Based on our findings, we hypothesise that BATKO mice differentially secrete factors that affect peripheral metabolism. Understanding the recruitment and regulation of different shades of adipose tissue is a crucial step towards pharmaceutically targeting a disadvantageous metabolic state. This thesis offers new insights on the dependence of whole body metabolism on the function of thermogenically active adipose tissue

Speculation Without Regret: Reducing Deoptimization Meta-data

Abstract Speculative optimizations are used in most Just In Time (JIT) compilers in order to take advantage of dynamic runtime feedback. These speculative optimizations usually require the compiler to produce meta-data that the Virtual Machine (VM) can use as fallback when a speculation fails. This meta-data can be large and incurs a significant memory overhead since it needs to be stored alongside the machine code for as long as the machine code lives. The design of the Graal compiler leads to many speculations falling back to a similar state and location. In this paper we present deoptimization grouping, an optimization using this property of the Graal compiler to reduce the amount of meta-data that must be stored by the VM without having to modify the VM. We compare our technique with existing meta-data compression techniques from the HotSpot Virtual Machine and study how well they combine. In order to make informed decisions about speculation meta-data, we present an empirical analysis of the origin, impact and usages of this meta-data

Towards Meta-Level Engineering and Tooling for Complex Concurrent Systems

With the widespread use of multicore processors, software becomes more and more diverse in its use of parallel computing resources. To address all application requirements, each with the appropriate abstraction, developers mix and match various concurrency abstractions made available to them via libraries and frameworks. Unfortunately, today's tools such as debuggers and profilers do not support the diversity of these abstractions. Instead of enabling developers to reason about the high-level programming concepts, they used to express their programs, the tools work only on the library's implementation level. While this is a common problem also for other libraries and frameworks, the complexity of concurrency exacerbates the issue further, and reasoning on the higher levels of the concurrency abstractions is essential to manage the associated complexity. In this position paper, we identify open research issues and propose to build tools based on a common meta-level interface to enable developers to reasons about their programs based on the high-level concepts they used to implement them

Cross-Language Compiler Benchmarking: Are We Fast Yet?

Comparing the performance of programming languages is difficult because they differ in many aspects including preferred programming abstractions, available frameworks, and their runtime systems. Nonetheless, the question about relative performance comes up repeatedly in the research community, industry, and wider audience of enthusiasts. This paper presents 14 benchmarks and a novel methodology to assess the compiler effectiveness across language implementations. Using a set of common language abstractions, the benchmarks are implemented in Java, JavaScript, Ruby, Crystal, Newspeak, and Smalltalk. We show that the benchmarks exhibit a wide range of characteristics using language-agnostic metrics. Using four different languages on top of the same compiler, we show that the benchmarks perform similarly and therefore allow for a comparison of compiler effectiveness across languages. Based on anecdotes, we argue that these benchmarks help language implementers to identify performance bugs and optimization potential by comparing to other language implementations

Trace Register Allocation Policies: Compile-time vs. Performance Trade-offs

Register allocation is an integral part of compilation, regardless of whether a compiler aims for fast compilation or optimal code quality. State-of-the-art dynamic compilers often use global register allocation approaches such as linear scan. Recent results suggest that non-global trace-based register allocation approaches can compete with global approaches in terms of allocation quality. Instead of processing the whole compilation unit (i.e., method) at once, a trace-based register allocator divides the problem into linear code segments, called traces. In this work, we present a register allocation framework that can exploit the additional flexibility of traces to select different allocation strategies based on the characteristics of a trace. This provides us with fine-grained control over the trade-off between compile time and peak performance in a just-in-time compiler. Our framework features three allocation strategies: a linear-scan-based approach that achieves good code quality, a single-pass bottom-up strategy that aims for short allocation times, and an allocator for trivial traces. To demonstrate the flexibility of the framework, we select 8 allocation policies and show their impact on compile time and peak performance. This approach can reduce allocation time by 7–43 at a peak performance penalty of about 1–11 on average. For systems that do not focus on peak performance, our approach allows to adjust the time spent for register allocation, and therefore the overall compilation time, thus finding the optimal balance between compile time and peak performance according to an application's requirements