New algorithms for shortest paths avoiding convex polygonal obstacles

Two algorithms are presented for computing shortest paths in the plane avoiding convex polygonal obstacles. For the first algorithm the obstacles are assumed to consist of f disjoint convex polygons, for the second algorithm the f polygons may intersect pairwise at most twice. For finding the shortest path between two arbitrary query points the first algorithm takes time O(nlogn + f^2logn) and space O(n), the second algorithm preprocesses the polygons in time O(nlogn + f^3) and space O(n + f^2). Thereafter one query takes time O(nlogn + f^2)

Maintaining a topological order under edge insertions

A topological order of the vertices of a directed acyclic graph G = (V,E) is any total order ord such that if (x, y) is an element of E, then x precedes y in ord. In this paper we consider the dynamic version of this problem, and provide simple algorithms and data structures achieving O(n) amortized time per edge insertion starting from an empty graph, which favorably compares to the trivial O(m+n) time bound per operation obtained applying the off-line algorithm. The additional space requirement, beside the representation of the graph itself, is O(n). Experimental results show that our algorithm performs in practice orders of magnitude faster than the off-line algorithm

Pattern-oriented software architecture : pattern for concurrent and networked objects

xxix+633hlm.;24c

On-line graph algorithms for incremental compilation

Compilers usually construct various data structures which often vary only slightly from compilation run to compilation run. This paper describes in a compact and uniform way solutions to several problems arising in order to quickly update these data structures instead of building them from scratch each time. All the considered problems can be reduced to graph problems. Specifically, we give algorithms for the dynamic problems of loop detection, topological order, reachability from the start routine, and transitive closure. As far as the dynamic maintenance of a topological order is concerned, for which no previous solution is known to the authors, simple algorithms and data structures are provided, and the achieved upper bound is O(n) amortized time per update in a sequence of O(m) edge insertions, which favourably compares to the trivial O(n+m) worst case time bound (applying the off-line algorithm). The additional space requirement, besides the space to represent the graph itself, is O(n). We also discuss by an example the harder fully dynamic version of topological order

Proactor - An Architectural Pattern for Demultiplexing and Dispatching Handlers for Asynchronous Events

Modern operating systems provide multiple mechanisms for developing concurrent applications. Synchronous multithreading is a popular mechanism for developing applications that perform multiple operations simultaneously. However, threads often have high performance overhead and require deep knowledge of synchronization patterns and principles. Therefore, an increasing number of operating systems support asynchronous mechanisms that provide the benefits of concurrency while alleviating much of the overhead and complexity of multi-threading. The Proactor pattern presented in this paper describes how to structure applications and systems that effectively utilize asynchronous mechanisms supported by operating systems. When an application invokes an asynchronous operation, the OS performs the operation on behalf of the application. This allows the application to have multiple operations running simultaneously without requiring the application to have a corresponding number of threads. Theref..