Mesa is a highly scalable analytic data warehousing system that stores critical measurement data related to Google's Internet advertising business. Mesa is designed to satisfy a complex and challenging set of user and systems requirements, including near real-time data ingestion and queryability, as well as high availability, reliability, fault tolerance, and scalability for large data and query volumes. Specifically, Mesa handles petabytes of data, processes millions of row updates per second, and serves billions of queries that fetch trillions of rows per day. Mesa is geo-replicated across multiple datacenters and provides consistent and repeatable query answers at low latency, even when an entire datacenter fails. This paper presents the Mesa system and reports the performance and scale that it achieves.

Many applications written in garbage collected languages have large dynamic working sets and poor data locality. We present a new system for continuously improving program data locality at run time with low overhead. Our system proactively reorganizes the heap by leveraging the garbage collector and uses profile information collected through a low-overhead mechanism to guide the reorganization at run time. The key contributions include making a case that garbage collection should be viewed as a proactive technique for improving data locality by triggering garbage collection for locality optimization independently of normal garbage collection for space, combining page and cache locality optimization in the same system, and demonstrating that sampling provides sufficiently detailed data access information to guide both page and cache locality optimization with low runtime overhead. We present experimental results obtained by modifying a commercial, state-of-the-art garbage collector to support our claims. Independently triggering garbage collection for locality optimization significantly improved optimizations benefits. Combining page and cache locality optimizations in the same system provided larger average execution time improvements (17%) than either alone (page 8%, cache 7%). Finally, using sampling limited profiling overhead to less than 3%, on average.

Automated program synthesis has not gained widespread acceptance among software practitioners despite considerable efforts by several researchers. We outline some of the difficulties in applying program synthesis for practical problems and argue that a careful analysis of the cost vs. benefit tradeoff is essential when considering such an approach. We describe a successful application of automated program generation for synthesizing geometric constraint satisfaction routines in the domain of mechanical CAD. We present a general framework for modeling and solving the problem, illustrate the framework using examples from the geometric constraint satisfaction domain, and describe experimental results on productivity increase using this approach. We also discuss characteristics of the problem domain and our approach that were critical for success.

A significant barrier inhibiting the use of parallel computing is the difficulty of writing parallel software. One solution to this problem is to build tools that can automatically convert sequential programs to parallel programs. In this paper we describe the implementation of a system that is designed to perform a semantic level analysis and transformation of algorithms in sequential programs. Our approach is based on pattern matching and has been inspired by recent research on reverse engineering and program understanding. We describe the architecture of our system, a pattern matching language that we have designed, our pattern matching strategy, and illustrate the approach and implementation using examples. This paper is a summary of the work.

We describe a knowledge-based framework for software reuse based on parameterizing and instantiating a generic architecture. The reuse process consists of two phases: (1) an acquisition phase, which creates knowledge components representing problem classes, generic architectures, and the design process, followed by: (2) a synthesis phase, which reuses the knowledge components in instantiating a generic architecture for new applications. We illustrate the process using two case studies in two different domains. The distinguishing features of our approach include the use of both formal and informal representations and the use of knowledge to assist software designers in designing new systems. We present empirical evidence, based on the case studies to argue that the approach improves productivity and reliability.

An important problem in geometric reasoning is to find the configuration of a collection of geometric bodies so as to satisfy a set of given constraints. Recently, it has been suggested that this problem can be solved efficiently by symbolically reasoning about geometry. This approach, called degrees of freedom analysis, employs a set of specialized routines called plan fragments that specify how to change the configuration of a set of bodies to satisfy a new constraint while preserving existing constraints. A potential drawback, which limits the scalability of this approach, is concerned with the difficulty of writing plan fragments. In this paper we address this limitation by showing how these plan fragments can be automatically synthesized using first principles about geometric bodies, actions, and topology.

We address a significant problem in parallel processing research, namely, how to port existing sequential programs to run efficiently on parallel machines (the dusty deck problem). Conventional domain-independent techniques are inadequate for solving this problem because they miss significant opportunities of parallelism. We present experimental evidence to support our claim, analyze why current techniques are inadequate, and propose a knowledge-based reverse engineering approach for attacking this problem. >

Article Process programming by hindsight Share on Authors: Pankaj K. Garg View Profile , Sanjay Bhansali View Profile Authors Info & Claims ICSE '92: Proceedings of the 14th international conference on Software engineeringJune 1992 Pages 280–293https://doi.org/10.1145/143062.143128Online:01 June 1992Publication History 6citation263DownloadsMetricsTotal Citations6Total Downloads263Last 12 Months2Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access