Yaniv Eytani

Towards a framework and a benchmark for testing tools for multi-threaded programs

Multi‐threaded code is becoming very common, both on the server side, and very recently for personal computers as well. Consequently, looking for intermittent bugs is a problem that is receiving more and more attention. As there is no silver bullet, research focuses on a variety of partial solutions. We outline a road map for combining the research within the different disciplines of testing multi‐threaded programs and for evaluating the quality of this research. We have three main goals. First, to create a benchmark that can be used to evaluate different solutions. Second, to create a framework with open application programming interfaces that enables the combination of techniques in the multi‐threading domain. Third, to create a focus for the research in this area around which a community of people who try to solve similar problems with different techniques can congregate. We have started creating such a benchmark and describe the lessons learned in the process. The framework will enable technology developers, for example, developers of race detection algorithms, to concentrate on their components and use other ready made components (e.g. an instrumentor) to create a testing solution. Copyright

Compiling a benchmark of documented multi-threaded bugs

Summary form only given. Testing multithreaded, concurrent, or distributed programs is acknowledged to be a very difficult task. We decided to create a benchmark of programs containing documented multithreaded bugs that can be used in the development of testing tool for the domain. In order to augment the benchmark with a sizable number of programs, we assigned students in a software testing class to write buggy multithreaded Java programs and document the bugs. This paper documents this experiment. We explain the task that was given to the students, go over the bugs that they put into the programs both intentionally and unintentionally, and show our findings. We believe this part of the benchmark shows typical programming practices, including bugs, of novice programmers. In grading the assignments, we used our technologies to look for undocumented bugs. In addition to finding many undocumented bugs, which was not surprising given that writing correct multithreaded code is difficult, we also found a number of bugs in our tools. We think this is a good indication of the expected utility of the benchmark for multithreaded testing tool creators.

Heuristics for finding concurrent bugs

This paper presents new heuristics that increase the probability of manifesting concurrent bugs. The heuristics are based on cross-run monitoring. A contended shared variable is chosen and random context switching is performed at accesses to that variable. The relative strength of the new heuristics is analyzed. In comparison to previous works, our heuristics increase the frequency of bug manifestation. In addition, the new heuristics were able to find bugs that previous methods did not discover.

Producing scheduling that causes concurrent programs to fail

A noise maker is a tool that seeds a concurrent program with conditional synchronization primitives (such as yield()) for the purpose of increasing the likelihood that a bug manifest itself. This work explores the theory and practice of choosing where in the program to induce such thread switches at runtime. We introduce a novel fault model that classifies locations as ¿good¿, ¿neutral¿, or ¿bad,¿ based on the effect of a thread switch at the location. We validate our approach by experimenting with a set of programs taken from publicly available multi-threaded benchmark. Our empirical evidence demonstrates that real-life behavior is similar to that derived from the model.

Concurrent Java Test Generation as a Search Problem

A Random test generator generates executable tests together with their expected results. In the form of a noise-maker, it seeds the program with conditional scheduling primitives (such as yield()) that may cause context switches. As a result different interleavings are potentially produced in different executions of the program. Determining a-priori the set of seeded locations required for a bug to manifest itself is rarely possible. This work proposes to reformulate random test generation of concurrent Java programs as a search problem. Hence, it allows applying a set of well known search techniques from the domain of AI to the input space of the test generator. By iteratively refining the input parameters fed to the test generator, the search process creates testing scenarios (i.e. interleavings) that maximizes predefined objective functions. We develop geneticFinder, a noise-maker that uses a genetic algorithm as a search method. We demonstrate our approach by maximizing two objective functions: the high manifestation rate of concurrent bugs and the exporting of a high degree of debugging information to the user. Experimental results show our approach is effective.

Measuring the Relative Performance of Schema Matchers

Schema matching is a complex process focusing on matching between concepts describing the data in heterogeneous data sources. There is a shift from manual schema matching, done by human experts, to automatic matching, using various heuristics (schema matchers). In this work, we consider the problem of linearly combining the results of a set of schema matchers. We propose the use of machine learning algorithms to learn the optimal weight assignments, given a set of schema matchers. We also suggest the use of genetic algorithms to improve the process efficiency.

EFFICIENT COLLABORATIVE FILTERING IN CONTENT-ADDRESSABLE SPACES

Collaborative Filtering (CF) is currently one of the most popular and most widely used personalization techniques. It generates personalized predictions based on the assumption that users with similar tastes prefer similar items. One of the major drawbacks of the CF from the computational point of view is its limited scalability since the computational effort required by the CF grows linearly both with the number of available users and items. This work proposes a novel efficient variant of the CF employed over a multidimensional content-addressable space. The proposed approach heuristically decreases the computational effort required by the CF algorithm by limiting the search process only to potentially similar users. Experimental results demonstrate that the proposed heuristic approach is capable of generating predictions with high levels of accuracy, while significantly improving the performance in comparison with the traditional implementations of the CF.

Semantic Platform for Context-Aware Publish/Subscribe M-Commerce

With the increasing popularity of mobile handheld devices, there is a pressing need for context-aware publish/subscribe systems over mobile environment. Publish/subscribe systems connect between information providers (publishing information in form of events) and the interested information consumers (subscribing to a particular category of events). We propose a novel approach for semantic context-aware publish/subscribe systems. Our approach replaces the traditional notion of manual subscription with a new form of automatic context-aware subscription, based on the users location, personal preferences and interests. This has a potential of raising the quality of use in mobile publish/subscribe applications.

Retrieval of Collaborative Filtering Nearest Neighbors in a Content-Addressable Space

Collaborative Filtering (CF) is considered one of the popular and most widely used recommendation techniques. It is aimed at generating personalized item recommendations for the users based on the assumption that similar users have similar preferences and like similar items. One of the major drawbacks of the CF is its limited scalability, as the CF computational effort increases linearly with the number of users and items. This work presents a novel variant of the CF, employed over a content-addressable space. This heuristically decreases the computational effort required by the CF by restricting the nearest neighbors search applied by the CF to a set potentially highly similar users. Experimental evaluation demonstrates that the proposed approach is capable of generating accurate recommendations, while significantly improving the performance in comparison with the traditional implementation of the CF.