Showing papers by "Darko Stefanovic published in 2005"

Randomized instruction set emulation

Abstract: Injecting binary code into a running program is a common form of attack. Most defenses employ a “guard the doors” approach, blocking known mechanisms of code injection. Randomized instruction set emulation (RISE) is a complementary method of defense, one that performs a hidden randomization of an application's machine code. If foreign binary code is injected into a program running under RISE, it will not be executable because it will not know the proper randomization. The paper describes and analyzes RISE, describing a proof-of-concept implementation built on the open-source Valgrind IA32-to-IA32 translator. The prototype effectively disrupts binary code injection attacks, without requiring recompilation, linking, or access to application source code. Under RISE, injected code (attacks) essentially executes random code sequences. Empirical studies and a theoretical model are reported which treat the effects of executing random code on two different architectures (IA32 and PowerPC). The paper discusses possible extensions and applications of the RISE technique in other contexts.

Deoxyribozyme-based ligase logic gates and their initial circuits.

Abstract: A complete set (YES, NOT, AND, and ANDNOT) of molecular scale logic gates based on ligase deoxyribozymes was constructed. The activity of these gates was visualized through the formation of cascades with downstream phosphodieseterase YES gates, which performed fluorogenic cleavage.

Computing with Nucleic Acids

Abstract: Exactly one decade has passed since Adleman’s seminal demonstration that biochemical operations can be performed on DNA in order to solve certain combinatorial problems [1]. So, the time seems ripe to critically analyze where the field stands, what has been accomplished, what needs to be accomplished, and perhaps most importantly, what are the realistic expectations in this field. A rational assessment is also pertinent because the whole field of DNA computing has come to be considered by many as being ‘‘more hype than substance’’ [2], and the practitioners in the field are partly to blame for this. Namely, initial opening in the field was so impressive and inspirational that it garnered understandable yet, in retrospect, completely unjustified exuberance about the potential applications of ‘‘DNA computers’’. As a result, it became standard in the field to put forward incredible predictions in the abstracts and conclusions of papers. This led to a situation where many very important advances in the field of DNA computing are viewed with suspicion by computer scientists and are misunderstood by biochemists. Misinterpretations in the popular press did not help either (not to mention the Schön affair in the somewhat related field of molecular electronics). In this respect, it is sobering to read the latest Science paper from Adleman [3], in which he scales the ‘‘Mount Everest’’ of DNA parallel computation (solving a 20-variable instance of 3-SAT), yet he puts the field in a realistic perspective. At the very beginning, we have to define what DNA computation is. Many examples in the literature do not compute anything tangible (in layman’s terms, at least), and in many cases, actual computation is not performed by DNA, but by a human operator. So we decided to discuss those approaches in which authors claim to be able to perform computation by using some type of DNA hybridization procedure. We will specifically exclude methods in which DNA is only incidentally used and in which, for example, Boolean behavior is actually displayed by proteins [4] or by cells. In particular, for reasons of space, we decided to focus only on those approaches that have appeared in mainstream peer-reviewed literature more than once (i.e., that established themselves), and we could not, for the most part, cover the abundant literature that appeared in various DNA Computation conferences. This review is split into four main sections according to the major thrusts in what could loosely be defined as ‘‘the field of DNA computation’’: (a) Adleman’s experiment

Towards practical biomolecular computers using microfluidic deoxyribozyme logic gate networks

Abstract: We propose a way of implementing a biomolecular computer in the laboratory using deoxyribozyme logic gates inside a microfluidic reaction chamber. We build upon our previous work, which simulated the operation of a flip-flop and an oscillator based on deoxyribozymes in a continuous stirred-tank reactor (CSTR). Unfortunately, using these logic gates in a laboratory-size CSTR is prohibitively expensive, because the reagent quantities needed are too large. This motivated our decision to design a microfluidic system. We would like to use a rotary mixer, so we examine how it operates, show how we have simulated its operation, and discuss how it affects the kinetics of the system. We then show the result of simulating both a flip-flop and an oscillator inside our rotary mixing chamber, and discuss the differences in results from the CSTR setting.

Designing nucleotide sequences for computation: a survey of constraints

Abstract: We survey common biochemical constraints useful for the design of DNA code words for DNA computation. We define the DNA Code Constraint Problem and cover biochemistry topics relevant to DNA libraries. We examine which biochemical constraints are best suited for DNA word design.

Building the components for a biomolecular computer

Abstract: We propose a new method for amorphous bio-compatible computing using deoxyribozyme logic gates [1] in which oligonucleotides act as enzymes on other oligonucleotides, yielding oligonucleotide products. Moreover, these reactions can be controlled by inputs that are also oligonucleotides. We interpret these reactions as logic gates, and the concentrations of chemical species as signals. Since these reactions are homogeneous, i.e., they use oligonucleotides as both inputs and outputs, we can compose them to construct complex logic circuits. Thus, our system for chemical computation offers functionality similar to conventional electronic circuits with the potential for deployment inside of living cells. Previously, this technology was demonstrated in closed-system batch reactions, which limited its computational ability to simple feed-forward circuits. In this work, we go beyond closed systems, and show how to use thermodynamically open reactors to build biomolecular circuits with feedback. The behavior of an open chemical system is determined both by its chemical reaction network and by the influx and efflux of chemical species. This motivates a change in design process from that used with closed systems. Rather than focusing solely on the stoichiometry of the chemical reactions, we must carefully examine their kinetics. Systems of differential equations and the theory of dynamical systems become the appropriate tools for designing and analyzing such systems. Using these tools, we present an inverter. Next, by introducing feedback into the reaction network, we construct devices with a sense of state. We show how a combination of analytical approximation techniques and numerical methods allows us to tune the dynamics of these systems. We demonstrate a flip-flop which exhibits behavior similar to the RS flip-flop of electronic computation. It has two states in which the concentration of one oligonucleotide is high and the other is low or vice versa. We describe how to control the state of the flip-flop by varying the concentration of the substrates. Moreover, there are large regions of parameter space in which this behavior is robust, and we show how to tune the influx rates as a function of the chemical reaction rates in a way that ensures bistability.

Garbage Collection With a Large Address Space for Server Applications.

Abstract: Abstract : We analyze the performance of several copying garbage collection algorithms in a large address space offered by modern architectures. In particular, we describe the design and implementation of the RealOF garbage collector, an algorithm explicitly designed to exploit the features of 64-bit environments. This collector maintains a correspondence between object age and object placement in the address space of the heap. It allocates and copies objects within designated regions of memory called zones and performs garbage collection incrementally by collecting one or more ranges of memory called windows. The address-ordered heap allows us to use the same inexpensive write barrier that works for traditional generational collectors. We show that for server applications this algorithm improves throughput and reduces heap size requirements over the best-throughput generational copying algorithms such as the Appel-style generational collector.

Comparison of Garbage Collectors Operating in a Large Address Space

Abstract: : We analyze the performance of several copying garbage collection algorithms in a large address space offered by modern architectures. In particular, we describe the design and implementation of the RealOF garbage collector, an algorithm explicitly designed to exploit the features of 64-bit environments. This collector maintains a correspondence between object age and object placement in the address space of the heap. It allocates and copies objects within designated regions of memory called zones and performs garbage collection incrementally by collecting one or more ranges of memory called windows. The windows are managed so as to collect middle-aged objects, rather than almost always collecting young objects, as with a generational collector. The address-ordered heap allows us to use the same inexpensive write barrier that works for generational collectors. We show that for server applications this algorithm improves throughput and reduces heap size requirements over the best-throughput generational copying algorithms such as the Appel-style generational collector.

A Study of Garbage Collection With a Large Address Space for Server Applications

Abstract: : We analyze the performance of several copying garbage collection algorithms in a large address space offered by modern architectures. In particular, we describe the design and implementation of the RealOF garbage collector, an algorithm explicitly designed to exploit the features of 64-bit environments. This collector maintains a correspondence between object age and object placement in the address space of the heap. It allocates and copies objects within designated regions of memory called zones and performs garbage collection incrementally by collecting one or more ranges of memory called windows. The address-ordered heap allows us to use the same inexpensive write barrier that works for traditional generational collectors. We show that for server applications this algorithm improves throughput and reduces heap size requirements over the best-throughput generational copying algorithms such as the Appel-style generational collector.