Context Of Calls Research Articles

Binary analysis for measurement and attribution of program performance

Modern programs frequently employ sophisticated modular designs. As a result, performance problems cannot be identified from costs attributed to routines in isolation; understanding code performance requires information about a routine's calling context. Existing performance tools fall short in this respect. Prior strategies for attributing context-sensitive performance at the source level either compromise measurement accuracy, remain too close to the binary, or require custom compilers. To understand the performance of fully optimized modular code, we developed two novel binary analysis techniques: 1) on-the-fly analysis of optimized machine code to enable minimally intrusive and accurate attribution of costs to dynamic calling contexts; and 2) post-mortem analysis of optimized machine code and its debugging sections to recover its program structure and reconstruct a mapping back to its source code. By combining the recovered static program structure with dynamic calling context information, we can accurately attribute performance metrics to calling contexts, procedures, loops, and inlined instances of procedures. We demonstrate that the fusion of this information provides unique insight into the performance of complex modular codes. This work is implemented in the HPCToolkit performance tools (http://hpctoolkit.org).

Go with the flow

Many large-scale Java applications suffer from runtime bloat. They execute large volumes of methods, and create many temporary objects, all to execute relatively simple operations. There are large opportunities for performance optimizations in these applications, but most are being missed by existing optimization and tooling technology. While JIT optimizations struggle for a few percent, performance experts analyze deployed applications and regularly find gains of 2x or more. Finding such big gains is difficult, for both humans and compilers, because of the diffuse nature of runtime bloat. Time is spread thinly across calling contexts, making it difficult to judge how to improve performance. Bloat results from a pile-up of seemingly harmless decisions. Each adds temporary objects and method calls, and often copies values between those temporary objects. While data copies are not the entirety of bloat, we have observed that they are excellent indicators of regions of excessive activity. By optimizing copies, one is likely to remove the objects that carry copied values, and the method calls that allocate and populate them. We introduce copy profiling , a technique that summarizes runtime activity in terms of chains of data copies. A flat copy profile counts copies by method. We show how flat profiles alone can be helpful. In many cases, diagnosing a problem requires data flow context. Tracking and making sense of raw copy chains does not scale, so we introduce a summarizing abstraction called the copy graph . We implement three clients analyses that, using the copy graph, expose common patterns of bloat, such as finding hot copy chains and discovering temporary data structures. We demonstrate, with examples from a large-scale commercial application and several benchmarks, that copy profiling can be used by a programmer to quickly find opportunities for large performance gains.

Fast and precise points-to analysis

Many software engineering applications require points-to analysis. These client applications range from optimizing compilers to integrated program development environments (IDEs) and from testing environments to reverse-engineering tools. Moreover, software engineering applications used in an edit-compile cycle need points-to analysis to be fast and precise. In this article, we present a new context- and flow-sensitive approach to points-to analysis where calling contexts are distinguished by the points-to sets analyzed for their call target expressions. Compared to other well-known context-sensitive techniques it is faster in practice, on average, twice as fast as the call string approach and by an order of magnitude faster than the object-sensitive technique. In fact, it shows to be only marginally slower than a context-insensitive baseline analysis. At the same time, it provides higher precision than the call string technique and is similar in precision to the object-sensitive technique. We confirm these statements with experiments using a number of abstract precision metrics and a concrete client application: escape analysis.

Wild Female Olive Baboons Adapt their Grunt Vocalizations to Environmental Conditions

AbstractSound propagates differently and visibility varies according to the habitat type. Animals should therefore adapt the acoustic structure and the usage of their vocal signals to the environment. In the present study, we examined the influence of the habitat on the vocal behaviour of wild olive baboons (Papio hamadryas anubis) in two populations: one living in Gashaka‐Gumti National Park, Nigeria, and the other in Budongo Forest, Uganda. We investigated whether female baboons modified the acoustic structure of their grunts and their rate of grunting when they wandered between closed and open habitat types. As an adaptation to the environmental conditions, baboons might utter calls with a longer duration, a lower fundamental frequency and/or energy concentrated in lower frequencies in a closed habitat like forest than in an open habitat. Baboons should also grunt more frequently in the closed habitat. Analyses showed that in both populations grunts uttered in forest were significantly longer than in open habitat. Additionally, baboons from Uganda showed a significantly higher grunt rate in forest than in open habitat. These results revealed a certain degree of plasticity in vocal production and call usage with regard to the habitat type. However, results in Nigeria suggested that, besides habitat structure, other proximate factors like the context of calling and the proximity between group members could also have an influence on the actual communication patterns.

A dependence graph-based representation for test coverage analysis of object-oriented programs

Test coverage analysis is used to determine the extent to which different features of interest are exercised by a given test suite. For object-oriented programs, it involves determining the extent to which features such as inheritance, polymorphism, dynamic binding, etc. are exercised. As object-oriented coverage analysis using only source code or object code is difficult and inefficient, the source code is converted to a suitable intermediate representation for subsequent analysis. We propose a dependence graph-based representation for object-oriented programs, named Call-based Object-Oriented System Dependence Graph (COSDG). COSDG captures the important object-oriented features, provides details of method visibility in a derived class, and differentiates various calling contexts with different type of method call edges: simple, inherited, and polymorphic. We also propose an algorithm to construct COSDG incrementally. Though COSDG has been developed primarily to aid test coverage analysis, it can be used in a variety of other software engineering applications also.

Compositional shape analysis by means of bi-abduction

This paper describes a compositional shape analysis, where each procedure is analyzed independently of its callers. The analysis uses an abstract domain based on a restricted fragment of separation logic, and assigns a collection of Hoare triples to each procedure; the triples provide an over-approximation of data structure usage. Compositionality brings its usual benefits -- increased potential to scale, ability to deal with unknown calling contexts, graceful way to deal with imprecision -- to shape analysis, for the first time. The analysis rests on a generalized form of abduction (inference of explanatory hypotheses) which we call bi-abduction . Bi-abduction displays abduction as a kind of inverse to the frame problem: it jointly infers anti-frames (missing portions of state) and frames (portions of state not touched by an operation), and is the basis of a new interprocedural analysis algorithm. We have implemented our analysis algorithm and we report case studies on smaller programs to evaluate the quality of discovered specifications, and larger programs (e.g., an entire Linux distribution) to test scalability and graceful imprecision.

Why do female Columbian ground squirrels (Spermophilus columbianus) give an estrus call?

Female Columbian ground squirrels ( Spermophilus columbianus (Ord, 1815)) sometimes emit a repetitive vocalization after copulation. We examined two possible explanations for why sexual selection would favor expression of these “estrus calls”: to encourage sperm competition through mating with additional males and to increase mate guarding by the consort male as a mechanism of postcopulatory female mate choice. During three annual mating periods, we observed mating behaviour, estrus calls, and postcopulatory behavioural interactions of free-ranging individuals. Predictions of the advertisement hypothesis were supported, as females typically solicited courtship interactions with nonconsort males directly after emitting an estrus call. Thus, females that emitted an estrus call were more likely to acquire additional matings than noncalling females, particularly if calls were emitted after the female’s first mating. These results were not consistent with predictions of the postcopulatory female mate choice hypothesis, as calling females should initiate social contact with the consort male and stay proximate to the copulatory site after copulation if they are encouraging mate guarding. For reasons that remain unclear, the probability that an estrus call would follow mating increased linearly with the age of the consort male. However, our results taken together suggest that estrus advertisement is the most likely social context of female postcopulatory calling.

Mining execution relations for crosscutting concerns

Aspect mining tries to identify crosscutting concerns in the code of existing systems and thus supports their adaption to an aspect-oriented design. A semi-automatic static aspect mining approach is described, where the program's control flow graphs are investigated for recurring execution patterns based on different constraints, such as the requirement that the patterns have to exist in different calling contexts. Two case studies done with the implemented tool show that many discovered candidates for crosscutting concerns are instances of delegation and should not be refactored into aspects. More generally, it is shown that aspect mining techniques need a way to distinguish between delegation and superimposed behaviour.

Probabilistic calling context

Calling context enhances program understanding and dynamic analyses by providing a rich representation of program location. Compared to imperative programs, object-oriented programs use more interprocedural and less intraprocedural control flow, increasing the importance of context sensitivity for analysis. However, prior online methods for computing calling context, such as stack-walking or maintaining the current location in a calling context tree, are expensive in time and space. This paper introduces a new online approach called probabilistic calling context (PCC) that continuously maintains a probabilistically unique value representing the current calling context. For millions of unique contexts, a 32-bit PCC value has few conflicts. Computing the PCC value adds 3% average overhead to a Java virtual machine. PCC is well-suited to clients that detect new or anomalous behavior since PCC values from training and production runs can be compared easily to detect new context-sensitive behavior; clients that query the PCC value at every system call, Java utility call, and Java API call add 0-9% overhead on average. PCC adds space overhead proportional to the distinct contexts stored by the client (one word per context). Our results indicate PCC is efficient and accurate enough to use in deployed software for residual testing, bug detection, and intrusion detection.

Performance tuning with instruction-level cost derived from call-stack sampling

Except for program-counter histogramming, most modern profiling tools summarize at the level of entire functions or basic blocks, with or without additional information such as calling context or call graphs. This paper explicates the value of information about the cost of specific instructions, relative to summaries that do not include it. A good source of this information is time-random sampling of the call stack. To get the diagnostic benefit of instruction costs it is not necessary to measure them with high precision or efficiency. In fact, manual sampling suffices quite well, when it can be used. Other benefits of call stack sampling are that it can be used with unmodified software and libraries, and it is easily confined to the time intervals of interest. As with other profiling techniques, it can be employed repeatedly to remove all significant performance problems in single-thread programs.

An empirical study of static program slice size

This article presents results from a study of all slices from 43 programs, ranging up to 136,000 lines of code in size. The study investigates the effect of five aspects that affect slice size. Three slicing algorithms are used to study two algorithmic aspects: calling-context treatment and slice granularity. The remaining three aspects affect the upstream dependencies considered by the slicer. These include collapsing structure fields, removal of dead code, and the influence of points-to analysis. The results show that for the most precise slicer, the average slice contains just under one-third of the program. Furthermore, ignoring calling context causes a 50% increase in slice size, and while (coarse-grained) function-level slices are 33% larger than corresponding statement-level slices, they may be useful predictors of the (finer-grained) statement-level slice size. Finally, upstream analyses have an order of magnitude less influence on slice size.

Behavioral context of call production by eastern North Pacific blue whales

We assessed the behavioral context of calls produced by blue whales Balaenoptera mus- culus off the California coast based on acoustic, behavioral, and dive data obtained through acoustic recording tags, sex determination from tissue sampling, and coordinated visual and acoustic obser- vations. Approximately one-third of 38 monitored blue whales vocalized, with sounds categorized into 3 types: (1) low-frequency pulsed A and tonal B calls, in either rhythmic repetitive song sequences or as intermittent, singular calls; (2) downswept D calls; and (3) highly variable amplitude- or frequency-modulated calls. Clear patterns of behavior, sex, and group size are evident for some call types. Only males were documented producing AB calls, with song produced by lone, traveling blue whales, and singular AB calls were more typically produced by whales in pairs; D calls were heard from both sexes during foraging, commonly from individuals within groups. The sex bias evi- dent in AB callers suggests that these calls probably play a role in reproduction, even though the calls are produced year-round. All calls are produced at shallow depth, and calling whales spend more time at shallow depths than non-calling whales, suggesting that a cost may be incurred during D call- ing, as less time is spent feeding at deeper depths. This relationship between calling and depth may predict the traveling behavior of singing blue whales, as traveling whales do not typically dive to deep depths and therefore would experience little extra energetic cost related to the production of long repetitive song bouts while moving between foraging areas.

CALF INSPECTIONS OF FISH CATCHES IN BOTTLENOSE DOLPHINS (TURSIOPS SP.): OPPORTUNITIES FOR OBLIQUE SOCIAL LEARNING?

In recent years, the study of social learning and culture in wild cetaceans has visibly increased (Rendell and Whitehead 2001, Mann and Sargeant 2003, Krutzen et al. 2005). Some of the best evidence for some type of social learning in wild cetaceans comes from studies of vocal traditions in killer whales (Deecke et al. 2000, Yurk et al. 2002), song change in humpback whales (Noad et al. 2000), coda dialects in sperm whales (Rendell and Whitehead 2005), whistle convergence in bottlenose dolphins (Smolker and Pepper 1999, Watwood et al. 2004), and foraging behaviors in bottlenose dolphins (Mann and Sargeant 2003, Sargeant et al. 2005). The mechanisms (e.g., local enhancement, imitation) of social transmission have received very little attention, largely because this requires well-controlled experiments, compounded further by the difficulties in studying marine mammals. In a broader sense, determining whether transmission is vertical (parent to offspring), oblique (older to younger), or horizontal (laterally to peers or similar age classes), even without precise determination of mechanisms, offers insights into the ecological and social demands of a species. For example, horizontal transmission of song types in humpback whales is consistent with the proposed competitive function of song (Noad et al. 2000, Cerchio et al. 2001), and the context of pod-specific calls in killer whales suggests that calls promote cohesiveness (Miller et al. 2004). To date, our work on Shark Bay bottlenose dolphins (Tursiops sp.) suggests that vertical transmission of foraging types from mother to calf are commonplace (Mann and Sargeant 2003), but other forms of transmission may also occur (Sargeant et al. 2005). We argue that habitat heterogeneity and bisexual philopatry favors vertical transmission, especially for daughters who, more than sons, maintain a range similar to the mother’s (Krutzen et al. 2004). For

Context-sensitive domain-independent algorithm composition and selection

Progressing beyond the productivity of present-day languages appears to require using domain-specific knowledge. Domain-specific languages and libraries (DSLs) proliferate, but most optimizations and language features have limited portability because each language's semantics are related closely to its domain. We explain how any DSL compiler can use a domain-independent AI planner to implement algorithm composition as a language feature . Our notion of composition addresses a common DSL problem: good library designers tend to minimize redundancy by including only fundamental procedures that users must chain together into call sequences. Novice users are confounded by not knowing an appropriate sequence to achieve their goal. Composition allows the programmer to define and call an abstract algorithm (AA) like a procedure. The compiler replaces an AA call with a sequence of library calls, while considering the calling context. Because AI planners compute a sequence of operations to reach a goal state, the compiler can implement composition by analyzing the calling context to provide the planner's initial state. Nevertheless, mapping composition onto planning is not straightforward because applying planning to software requires extensions to classical planning, and procedure specifications may be incomplete when expressed in a planning language. Compositions may not be provably correct, so our approach mitigates semantic incompleteness with unobtrusive programmer-compiler interaction. This tradeoff is key to making composition a practical and natural feature of otherwise imperative languages, whose users eschew complex logical specifications. Compositions satisfying an AA may not be equal in performance, memory usage, or precision and require selection of a preferred solution. We examine language design and implementation issues, and we perform a case study on the BioPerl bioinformatics library.

Accurate, efficient, and adaptive calling context profiling

Calling context profiles are used in many inter-procedural code optimizations and in overall program understanding. Unfortunately, the collection of profile information is highly intrusive due to the high frequency of method calls in most applications. Previously proposed calling-context profiling mechanisms consequently suffer from either low accuracy, high overhead, or both. We have developed a new approach for building the calling context tree at runtime, called adaptive bursting . By selectively inhibiting redundant profiling, this approach dramatically reduces overhead while preserving profile accuracy. We first demonstrate the drawbacks of previously proposed calling context profiling mechanisms. We show that a low-overhead solution using sampled stack-walking alone is less than 50% accurate, based on degree of overlap with a complete calling-context tree. We also show that a static bursting approach collects a highly accurate profile, but causes an unacceptable application slowdown. Our adaptive solution achieves 85% degree of overlap and provides an 88% hot-edge coverage when using a 0.1 hot-edge threshold, while dramatically reducing overhead compared to the static bursting approach.

On the ‘Africanization’ of English Studies in South Africa

The article is an exploration of current trends within, and the desired destiny of, the humanities discipline of English Studies in the context of calls for the ‘Africanization’ of South African universities.The essay advocates the embrace of a non-universalist, emancipationist humanism.

Using software design methods in CALL

The phrase ‘software design’ is not one that arouses the interest of many CALL practitioners, particularly those from a humanities background. However, software design essentials are simply logical ways of going about designing a system. The fundamentals include modularity, anticipation of change, generality and an incremental approach. While CALL researchers and developers might consider software design as something that is required for large-scale projects, it is relevant and useful for all types of projects. Colpaert's CALL design model incorporates software design principles and has a particular focus on CALL. This article reviews software design principles and their relevance in CALL. It focuses on how Colpaert's model can be applied in a real-world situation. One key feature is the importance of involving users (and especially teachers in the CALL context) in the design process. Although this can be challenging for the designer and the design-novice teacher, it is an essential component in successful CALL projects. This article aims to demonstrate that software design principles are not just lofty ideas but guidelines that can be used in a practical and pragmatic approach to CALL research and development. Those in the CALL world who come from a software engineering background can contribute to CALL by making software design principles more accessible to CALL practitioners, while those from other backgrounds can contribute by trying to understand and implement these concepts. This article aims to show less-technically oriented CALL practitioners the benefits of using software design principles in their work and, even if they do not manage to implement all of them, these principles can be used as a good and reliable model to follow.

Can humans discriminate between dogs on the base of the acoustic parameters of barks?

In this study we tested the often suggested claim that people are able to recognize their dogs by their barks. Earlier studies in other species indicated that reliable discrimination between individuals cannot be made by listening to chaotically noisy vocalizations. As barking is typically such a chaotic noisy vocalization, we have hypothesized that reliable discrimination between individuals is not possible by listening to barks. In this study, playback experiments were conducted to explore (1) how accurately humans discriminate between dogs by hearing only their barks, (2) the impact of the eliciting context of calls on these discrimination performances, and (3) how much such discrimination depends on acoustic parameters (tonality and frequency of barks, and the intervals between the individual barks). Our findings were consistent with the previous studies: human performances did not pass the empirical threshold of reliable discrimination in most cases. But a significant effect of tonality was found: discrimination between individuals was more successful when listeners were listening to low harmonic-to-noise ratio (HNR) barks. The contexts in which barks were recorded affected significantly the listeners' performances: if the dog barked at a stranger, listeners were able to discriminate the vocalizations better than if they were listening to sounds recorded when the dog was separated from its owner. It is rendered probable that the bark might be a more efficient communication system between humans and dogs for communicating the motivational state of an animal than for discrimination among strange individuals.

The 1994 annual lecture of the Society for the Study of Addiction. Commissions (Royal and other) on drug misuse: who needs them?

In the context of current calls in the United Kingdom for a Royal Commission on drugs, the political antecedents and consequences of nine major commissions of enquiry into drugs established by governments in the English-speaking world during the last 100 years are described, together with available information on their modus operandi and costs. The different interest groups calling for reform of UK drug laws are described and the broad basis on which a putative Royal Commission might proceed is suggested. Finally, analysis of previous commissions is used to identify factors likely to lead to a new Commission having a substantial influence on government policy on drugs.

Optimising aspectJ

AspectJ, an aspect-oriented extension of Java, is becoming increasingly popular. However, not much work has been directed at optimising compilers for AspectJ. Optimising AOP languages provides many new and interesting challenges for compiler writers, and this paper identifies and addresses three such challenges.First, compiling around advice efficiently is particularly challenging. We provide a new code generation strategy for around advice, which (unlike previous implementations) both avoids the use of excessive inlining and the use of closures. We show it leads to more compact code, and can also improve run-time performance. Second, woven code sometimes includes run-time tests to determine whether advice should execute. One important case is the cflow pointcut which uses information about the dynamic calling context. Previous techniques for cflow were very costly in terms of both time and space. We present new techniques to minimise or eliminate the overhead of cflow using both intra- and inter-procedural analyses. Third, we have addressed the general problem of how to structure an optimising compiler so that traditional analyses can be easily adapted to the AOP setting.We have implemented all of the techniques in this paper in abc , our AspectBench Compiler for AspectJ, and we demonstrate significant speedups with empirical results. Some of our techniques have already been integrated into the production AspectJ compiler, ajc 1.2.1.