Michael Stepp

Dynamic path-based software watermarking

Software watermarking is a tool used to combat software piracy by embedding identifying information into a program. Most existing proposals for software watermarking have the shortcoming that the mark can be destroyed via fairly straightforward semantics-preserving code transformations. This paper introduces path-based watermarking, a new approach to software watermarking based on the dynamic branching behavior of programs. The advantage of this technique is that error-correcting and tamper-proofing techniques can be used to make path-based watermarks resilient against a wide variety of attacks. Experimental results, using both Java bytecode and IA-32 native code, indicate that even relatively large watermarks can be embedded into programs at modest cost.

Equality saturation: a new approach to optimization

Optimizations in a traditional compiler are applied sequentially, with each optimization destructively modifying the program to produce a transformed program that is then passed to the next optimization. We present a new approach for structuring the optimization phase of a compiler. In our approach, optimizations take the form of equality analyses that add equality information to a common intermediate representation. The optimizer works by repeatedly applying these analyses to infer equivalences between program fragments, thus saturating the intermediate representation with equalities. Once saturated, the intermediate representation encodes multiple optimized versions of the input program. At this point, a profitability heuristic picks the final optimized program from the various programs represented in the saturated representation. Our proposed way of structuring optimizers has a variety of benefits over previous approaches: our approach obviates the need to worry about optimization ordering, enables the use of a global optimization heuristic that selects among fully optimized programs, and can be used to perform translation validation, even on compilers other than our own. We present our approach, formalize it, and describe our choice of intermediate representation. We also present experimental results showing that our approach is practical in terms of time and space overhead, is effective at discovering intricate optimization opportunities, and is effective at performing translation validation for a realistic optimizer.

More on graph theoretic software watermarks: Implementation, analysis, and attacks

This paper presents an implementation of the watermarking method proposed by Venkatesan et al. in their paper [R. Venkatesan, V. Vazirani, S. Sinha, A graph theoretic approach to software watermarking, in: Fourth International Information Hiding Workshop, Pittsburgh, PA, 2001]. An executable program is marked by the addition of code for which the topology of the control-flow graph encodes a watermark. We discuss issues that were identified during construction of an actual implementation that operates on Java bytecode. We present two algorithms for splitting a watermark number into a redundant set of pieces and an algorithm for turning a watermark number into a control-flow graph. We measure the size and time overhead of watermarking, and evaluate the algorithm against a variety of attacks.

Equality-based translation validator for LLVM

We updated our Peggy tool, previously presented in [6], to perform translation validation for the LLVM compiler using a technique called Equality Saturation. We present the tool, and illustrate its effectiveness at doing translation validation on SPEC 2006 benchmarks.

Generating compiler optimizations from proofs

We present an automated technique for generating compiler optimizations from examples of concrete programs before and after improvements have been made to them. The key technical insight of our technique is that a proof of equivalence between the original and transformed concrete programs informs us which aspects of the programs are important and which can be discarded. Our technique therefore uses these proofs, which can be produced by translation validation or a proof-carrying compiler, as a guide to generalize the original and transformed programs into broadly applicable optimization rules. We present a category-theoretic formalization of our proof generalization technique. This abstraction makes our technique applicable to logics besides our own. In particular, we demonstrate how our technique can also be used to learn query optimizations for relational databases or to aid programmers in debugging type errors. Finally, we show experimentally that our technique enables programmers to train a compiler with application-specific optimizations by providing concrete examples of original programs and the desired transformed programs. We also show how it enables a compiler to learn efficient-to-run optimizations from expensive-to-run super-optimizers.

Growing fat graphs

We present an algorithm for growing fat graphs. Traditionally, graph drawing algorithms represent vertices as circles and edges as closed curves connecting the vertices. The thickness of an edge is often used as a visualization cue, to indicate importance, or to convey some additional information. We show how to grow fat graphs with edges of variable thickness. For the purpose of the demonstration we focus on a restricted class of graphs that occur in VLSI wire routing. This class corresponds to planar, max-degree-1 graphs. The underlying algorithm also extends to general planar graphs as shown in [2]. In VLSI wire routing it is often desirable to maximize the distance between different wires. Maximizing the distance between wires is equivalent to finding the drawing in which the edges are drawn as thick as possible, i.e., allowing the graph to grow as fat as possible. The continuous homotopic routing problem [1, 3, 5] is a classic VLSI problem. The input is an initial sketch of the wiring (i.e., each wire is given a specified homotopy class), where the wires have fixed terminals. The goal is to route the wires with maximal separation between the wires, while preserving the homotopy. It is easy to see that this problem can be rephrased as the following fat-graph problem: find a planar drawing in which all the edges are drawn as fat as possible. Note that if the wiring sketch is not given or the terminals are not fixed, the problem is NP-hard [6]. The video shows the main steps of our algorithm: (1) an arbitrary wire routing is converted to a homotopic equivalent routing such that the distance between any two wires is maximized and the routing uses the wire lengths are minimized; (2) the wires are let to grow and (3) after the growth process terminates, the medial axis of each fat edge is used to route the corresponding wire. The running time of our algorithm is O(kn+ n) and the space required is O(k + n) where n is the number of wires and k is the maximum of the input and output complexities. Note that k can be much larger than n. Even after shortest paths have been computed for each wire, k can be as large as k = Ω(2) [2]. We are now ready to outline the general technique for

Collaboration with diamondtouch

We study the performance of collaborative spatial/visual tasks under different input configurations. The configurations used are a traditional mouse-monitor, a shared-monitor with multiple-mice, and a multi-user input device (DiamondTouch). Our experiments indicate that there is a significant variation in performance for the different configurations with pairs of users, while there is no such variation with individual users. The traditional configuration is not well-suited for collaborative tasks, and even after augmenting it to a shared monitor with multiple-mice it is still significantly inferior to the multi-user input device.