Disease burden due to Streptococcus dysgalactiae subsp equisimilis (group G and C streptococcus) is higher than that due to Streptococcus pyogenes among Mumbai school children

Streptococcus pyogenes [group A streptococcus (GAS)], a human pathogen, and Streptococcus dysgalactiae subsp. equisimilis [human group G and C streptococcus (GGS/GCS)] are evolutionarily related, share the same tissue niche in humans, exchange genetic material, share up to half of their virulence-associated genes and cause a similar spectrum of diseases. Yet, GGS/GCS is often considered as a commensal bacterium and its role in streptococcal disease burden is under-recognized. While reports of the recovery of GGS/GCS from normally sterile sites are increasing, studies describing GGS/GCS throat colonization rates relative to GAS in the same population are very few. This study was carried out in India where the burden of streptococcal diseases, including rheumatic fever and rheumatic heart disease, is high. As part of a surveillance study, throat swabs were taken from 1504 children attending 7 municipal schools in Mumbai, India, during 2006-2008. GAS and GGS/GCS were identified on the basis of beta-haemolytic activity, carbohydrate group and PYR test, and were subsequently typed. The GGS/GCS carriage rate (1166/1504, 11%) was eightfold higher than the GAS carriage (22/1504, 1.5%) rate in this population. The 166 GGS/GCS isolates collected represented 21 different emm types (molecular types), and the 22 GAS isolates represented 15 different emm types. Although the rate of pharyngitis associated with GGS/GCS is marginally lower than with GAS, high rates of throat colonization by GGS/GCS underscore its importance in the pathogenesis of pharyngitis.

Multithreaded Test Synthesis for Deadlock Detection

Designing and implementing thread-safe multithreaded libraries can be a daunting task as developers of these libraries need to ensure that their implementations are free from concurrency bugs, including deadlocks. The usual practice involves employing software testing and/or dynamic analysis to detect. deadlocks. Their effectiveness is dependent on well-designed multithreaded test cases. Unsurprisingly, developing multithreaded tests is significantly harder than developing sequential tests for obvious reasons. In this paper, we address the problem of automatically synthesizing multithreaded tests that can induce deadlocks. The key insight to our approach is that a subset of the properties observed when a deadlock manifests in a concurrent execution can also be observed in a single threaded execution. We design a novel, automatic, scalable and directed approach that identifies these properties and synthesizes a deadlock revealing multithreaded test. The input to our approach is the library implementation under consideration and the output is a set of deadlock revealing multithreaded tests. We have implemented our approach as part of a tool, named OMEN1. OMEN is able to synthesize multithreaded tests on many multithreaded Java libraries. Applying a dynamic deadlock detector on the execution of the synthesized tests results in the detection of a number of deadlocks, including 35 real deadlocks in classes documented as thread-safe. Moreover, our experimental results show that dynamic analysis on multithreaded tests that are either synthesized randomly or developed by third-party programmers are ineffective in detecting the deadlocks.

Synthesizing Racy Tests

Subtle concurrency errors in multithreaded libraries that arise because of incorrect or inadequate synchronization are often difficult to pinpoint precisely using only static techniques. On the other hand, the effectiveness of dynamic race detectors is critically dependent on multithreaded test suites whose execution can be used to identify and trigger races. Usually, such multithreaded tests need to invoke a specific combination of methods with objects involved in the invocations being shared appropriately to expose a race. Without a priori knowledge of the race, construction of such tests can be challenging. In this paper, we present a lightweight and scalable technique for synthesizing precisely these kinds of tests. Given a multithreaded library and a sequential test suite, we describe a fully automated analysis that examines sequential execution traces, and produces as its output a concurrent client program that drives shared objects via library method calls to states conducive for triggering a race. Experimental results on a variety of well-tested Java libraries yield 101 synthesized multithreaded tests in less than four minutes. Analyzing the execution of these tests using an off-the-shelf race detector reveals 187 harmful races, including several previously unreported ones.

PolyMage: Automatic Optimization for Image Processing Pipelines

This paper presents the design and implementation of PolyMage, a domain-specific language and compiler for image processing pipelines. An image processing pipeline can be viewed as a graph of interconnected stages which process images successively. Each stage typically performs one of point-wise, stencil, reduction or data-dependent operations on image pixels. Individual stages in a pipeline typically exhibit abundant data parallelism that can be exploited with relative ease. However, the stages also require high memory bandwidth preventing effective utilization of parallelism available on modern architectures. For applications that demand high performance, the traditional options are to use optimized libraries like OpenCV or to optimize manually. While using libraries precludes optimization across library routines, manual optimization accounting for both parallelism and locality is very tedious. The focus of our system, PolyMage, is on automatically generating high-performance implementations of image processing pipelines expressed in a high-level declarative language. Our optimization approach primarily relies on the transformation and code generation capabilities of the polyhedral compiler framework. To the best of our knowledge, this is the first model-driven compiler for image processing pipelines that performs complex fusion, tiling, and storage optimization automatically. Experimental results on a modern multicore system show that the performance achieved by our automatic approach is up to 1.81x better than that achieved through manual tuning in Halide, a state-of-the-art language and compiler for image processing pipelines. For a camera raw image processing pipeline, our performance is comparable to that of a hand-tuned implementation.