Type Inference for Deadlock Detection in a Multithreaded Polymorphic Typed Assembly Language

We previously developed a polymorphic type system and a type checker for a multithreaded lock-based polymorphic typed assembly language (MIL) that ensures that well-typed programs do not encounter race conditions. This paper extends such work by taking into consideration deadlocks. The extended type system verifies that locks are acquired in the proper order. Towards this end we require a language with annotations that specify the locking order. Rather than asking the programmer (or the compiler's backend) to specifically annotate each newly introduced lock, we present an algorithm to infer the annotations. The result is a type checker whose input language is non-decorated as before, but that further checks that programs are exempt from deadlocks

Ecosystem services and the idea of shared values

Ecosystem services conceptualise the diverse values that ecosystems provide to humanity. This was recognised in the United Kingdom's National Ecosystem Assessment, which noted that appreciation of the full value of ecosystem services requires recognition of values that are shared. By operationalising the shared values concept, it is argued that the contribution of ecosystem services to human well-being can be represented more holistically. This paper considers current understanding of shared values and develops a new metanarrative of shared values beyond the aggregated utilities of individuals. This metanarrative seeks to conceptualise how values can be held both individually and communally, and what this means for identifying their scale and means of enumeration. The paper poses a new reading of the idea of shared values that reconciles the elicitation of preformed individual values with the formation and expression of shared social values. The implication is that shared values need to be conceived as normative constructs that are derived through social processes of value formation and expression. Shared values thus do not necessarily exist a priori; they can be deliberated through formal and informal processes through which individuals can separate their own preferences from a broader metanarrative about what values ought to be shared

Runtime Performance Analysis of the M-to-N Scheduling Model

The popular M-to-N thread scheduling model multiplexes many user-level threads on top of fewer kernel-level threads. While this model is designed to be scalable and efficient without excessive resource consumption, we isolate several elementary examples under which the M-to-N model exhibits highly nonintuitive performance. We use a runtime performance monitor for multithreaded programs which we have developed, ThreadMon, to explain the causes of the unexpected results. We conclude that the complexity and nondeterminism exported to the programmer make performance tuning to the intricate M-to-N model extremely difficult. Moreover, we show that the insulation of user-level scheduling from kernel-level scheduling can have undesirable side-effects. 1 Introduction Since the approval of the POSIX threads standard [6], multithreaded programming has experienced an explosion of interest. Many applications have appreciated performance gains through multithreading; the popular Netscape web browse..

ThreadMon A Tool for Monitoring Multithreaded Program Performance

This paper describes ThreadMon, a monitoring tool for improving the performance of multithreaded programs. Traditional tools, e.g., gprof, thread analyzer, etc., present overall indications of performance, such as the total number of calls to each procedure, the time spent in each function, who called whom how often, etc. This information is not correlated with the passage of time. For time-critical programs, however, it is crucial to relate performance data to the events to which the program is responding: it is not enough to know where a program has spent its time, we must know when the program spent that time. In addition, to take full advantage of a multiprocessor, we need to know when the program is spending its time on which processors. Rather than present such information after the program has executed, we present it while the program is running, thus making it easy to relate our interactions with the subject program to the performance data being displayed. 1 Introduction Even..