Alex Brodsky

Characterizations of 1-Way Quantum Finite Automata

The 2-way quantum finite automaton introduced by Kondacs and Watrous [Proceedings of the 38th Annual Symposium on Foundations of Computer Science, 1997, IEEE Computer Society, pp. 66--75] can accept nonregular languages with bounded error in polynomial time. If we restrict the head of the automaton to moving classically and to moving only in one direction, the acceptance power of this 1-way quantum finite automaton is reduced to a proper subset of the regular languages. In this paper we study two different models of 1-way quantum finite automata. The first model, termed measure-once quantum finite automata, was introduced by Moore and Crutchfield [ Theoret. Comput. Sci., 237 (2000), pp. 275--306], and the second model, termed measure-many quantum finite automata, was introduced by Kondacs and Watrous [Proceedings of the38th Annual Symposium on Foundations of Computer Science, 1997, IEEE Computer Society, pp. 66--75]. We characterize the measure-once model when it is restricted to accepting with bounded error and show that, without that restriction, it can solve the word problem over the free group. We also show that it can be simulated by a probabilistic finite automaton and describe an algorithm that determines if two measure-once automata are equivalent. We prove several closure properties of the classes of languages accepted by measure-many automata, including inverse homomorphisms, and provide a new necessary condition for a language to be accepted by the measure-many model with bounded error. Finally, we show that piecewise testable sets can be accepted with bounded error by a measure-many quantum finite automaton, introducing new construction techniques for quantum automata in the process.

Fully-adaptive algorithms for long-lived renaming

Long-lived renaming allows processes to repeatedly get distinct names from a small name space and release these names. This paper presents two long-lived renaming algorithms in which the name a process gets is bounded above by the number of processes currently occupying a name or performing one of these operations. The first algorithm is asynchronous, uses LL/SC objects, and has step complexity that is linear in the number of processes, c, currently getting or releasing a name. The second is synchronous, uses registers and counters, and has step complexity that is polylogarithmic in c. Both tolerate any number of process crashes.

On the complexity of buffer allocation in message passing systems

Message passing programs commonly use message buffers to avoid unnecessary synchronizations and to improve performance by overlapping communication with computation. Unfortunately, using buffers can introduce portability problems and can lead to deadlock problems on systems without a sufficient number of message buffers. We explore a variety of problems related to buffer allocation for safe and efficient execution of message passing programs. We show that determining the minimum number of message buffers or verifying that each process has a sufficient number of message buffers are intractable problems. However, we give a polynomial time algorithm to determine the minimum number of message buffers needed to ensure that no send operation is unnecessarily delayed due to lack of message buffers. We extend these results to several different buffering schemes, which in some cases make the problems tractable.

Using file-grain connectivity to implement a peer-to-peer file system

Recent work has demonstrated a peer-to-peer storage system that locates data objects using O(logN) messages by placing objects on nodes according to pseudo-randomly chosen IDs. While elegant, this approach constrains system functionality and flexibility: files are immutable, directories and symbolic names are not supported, data location is fixed, and access locality is not exploited. This paper presents Mammoth, a peer-to-peer hierarchical file system that, unlike alternative approaches, supports a traditional file-system API, allows files and directories to be stored on any node, and adapts storage location to exploit locality, balance load, and ensure availability. Our approach handles all coordination at the granularity of files instead of nodes. In effect, the nodes that store a particular file act as its server independently of other nodes in the system. The resulting system is highly available and robust to failure. Our experiments with our prototype have yielded good results, but an important question remains: how the system will perform on a massive scale. We discuss the key issues, some of which we have addressed and others that remain open.

Efficient synchronous snapshots

A snapshot is an important object in distributed computing whose implementation in asynchronous systems has been studied extensively. It consists of a collection of <i>m</i> >1 components, each storing a value, and supports two atomic operations: an UPDATE of a specified components value and a SCAN of all components to determine their values at some point in time.In this paper, we investigate implementations of a multiwriter snapshot object in a synchronous shared memory model. In this setting, we show that a snapshot object can be efficiently implemented and prove a tight tradeoff between the complexity of the SCAN and the UPDATE operations. First, we describe a wait-free implementation that performs UPDATE in <i>O</i>(1) time and SCAN in <i>O</i>(<i>m</i>) time, using only slightly more than twice the amount of space needed to simply store the <i>m</i> values. We also describe a variant that performs UPDATE in <i>O</i>(1) time and SCAN in <i>O</i>(<i>n</i>) time.Second, we describe a wait-free implementation that performs UPDATE in <i>O</i>(log <i>m</i>) time and SCAN in <i>O</i>(1) time, and a variant that performs UPDATE in <i>O</i>(log <i>n</i>) time and SCAN in <i>O</i>(1) time.Third, we show how to combine these implementations to realize two implementations that perform UPDATE in Θ(log(<i>m/c</i>)) time and SCAN in Θ(<i>c</i>) time, for 1≤c≤m, or perform UPDATE in Θ(log(<i>n/c</i>)) time and SCAN in Θ(<i>c</i>) time, for 1≤c≤n. This implies that Time[UPDATE] ∈<i>O</i>(log(min<i>m</i>,<i>n</i>/Time[SCAN])). We also prove that Time[UPDATE] ∈ Ω(log(min<i>m</i>,<i>n</i>/Time[SCAN]) ), which matches our upper bound.

Restricted stack implementations

We introduce a new object, BH, and prove that a system with one BH object and single-writer Registers has the same computational power as a system with countably many commutative and overwriting objects. This provides a simple characterization of the class of objects that can be implemented from commutative and overwriting objects, and creates a potential tool for proving impossibility results. It has been conjectured that Stacks and Queues shared by three or more processes are not in this class. In this paper, we use a BH object to show that two different restricted versions of Stacks are in this class. Specifically, we give an implementation of a Stack that supports any number of poppers, but at most two pushers. We also implement a Stack (or Queue) shared by any number of processes, but, in which, all stored elements are the same.

Reversible Circuit Realizations of Boolean Functions

Reversible circuits are a concrete model of reversible computation with applications in areas such as quantum computing and analysis of cryptographic block cyphers. In 1980, Toffoli showed how to realize a Boolean function by a reversible circuit, however the resulting complexity of such circuits has remained an open problem. We investigate the reversible circuit complexity of families of Boolean functions and derive conditions that characterize whether a polynomial realization is possible.

Trinitya: distributed defense against transient spam-bots

Transient spam-bots are hijacked computers that are connected to the Internet for short periods of time, during which they send large amounts of spam. These spam-bots have become a principle source of spam; against which, static countermeasures such as DNS Black Lists are largely ineffective, and content-based filters provide temporary relief without ongoing tuning and upgrading---a never-ending cat-and-mouse game. This is a brief overview of Trinity [1], a distributed, content independent, spam classification system that is specifically aimed at transient spam-bots. Trinity uses source identification in combination with a peer-to-peer based distributed database to identify and track transient spam-bots. Trinitys design load balances the task of tracking the transient spam-bots and provides a robust defense against denial-of-service and malevolent peer attacks.

Approximating the buffer allocation problem using epochs

The correctness of applications that perform asynchronous message passing typically relies on the underlying hardware having a sufficient amount of memory (message buffers) to hold all undelivered messages-such applications may deadlock when executed on a system with an insufficient number of message buffers. Thus, determining the minimum number of buffers that an application needs to prevent deadlock is an important task when writing portable parallel applications. Unfortunately, both this problem (called the Buffer Allocation Problem) and the simpler problem of determining whether an application may deadlock for a given number of available message buffers are intractable [A. Brodsky, J. Pedersen, A. Wagner, On the complexity of buffer allocation in message passing systems, Journal of Parallel and Distributed Computing 65 (2005) 692-713]. We present a new epoch-based polynomial-time approach for approximating a solution to the Buffer Allocation Problem. Our approach partitions application executions into epochs and intersperses barrier synchronizations between them, thus limiting the number of message buffers necessary to ensure deadlock-freedom. This approach produces near optimal solutions for many common cases and can be adapted to guide application modifications that ensure deadlock-freedom when the application is executed on different systems. We describe a prototype implementation, and present an empirical evaluation of this approach. Lastly, we describe a space-time trade-off between the number of available message buffers and the number of barrier synchronizations, and describe how this trade-off can be used to fine-tune application performance.

Our brothers' keepers

The Trinity [BB07] spam classification system is based on a distributed hash table that is implemented using a structured peer-to-peer overlay. Such an overlay must be capable of processing hundreds of messages per second, and must be able to route messages to their destination even in the presence of failures and malicious peers that misroute packets or inject fraudulent routing information into the system. Typically there is tension between the requirements to route messages securely and efficiently in the overlay. We describe a secure and efficient routing extension that we developed within the I3 [SAZ04] implementation of the Chord [SMK01] overlay. Secure routing is accomplished through several complementary approaches: First, peers in close proximity form overlapping groups that police themselves to identify and mitigate fraudulent routing information. Second, a form of random routing solves the problem of entire packet flows passing through a malicious peer. Third, a message authentication mechanism links each message to it sender, preventing spoofing. Fourth, each peer’s identifier links the peer to its network address, and at the same time uniformly distributes the peers in the key-space. Lastly, we present our initial evaluation of the system, comprising a 255 peer overlay running on a local cluster. We describe our methodology and show that the overhead of our secure implementation is quite reasonable. keywords: secure routing, peer authentication, distributed hash tables ∗This research was supported by an NSERC Discovery grant. ar X iv :0 80 8. 17 44 v1 [ cs .D C ] 1 2 A ug 2 00 8