PAVE: parallel algorithms visually explored, a prototype tool for the investigation of data structures in parallel numerical iterative algorithms

Author(s):  
E.J. Stuart ◽  
J.S. Weston
1996 ◽  
Vol 06 (01) ◽  
pp. 35-44 ◽  
Author(s):  
DANY BRESLAUER ◽  
RAMESH HARIHARAN

This paper gives optimal parallel algorithms for the construction of the smallest deterministic finite automata recognizing all the suffixes and the factors of a string. The algorithms use recently discovered optimal parallel suffix tree construction algorithms together with data structures for the efficient manipulation of trees, exploiting the well known relation between suffix and factor automata and suffix trees.


2011 ◽  
Vol 130-134 ◽  
pp. 3010-3014
Author(s):  
Ren Jian Li ◽  
Zhao Fei Wang ◽  
Long Ming Dong

Current symbolic execution is challenged by its ability to deal with loops. The case gets worse for loops manipulating recursive data structures. In this paper, we extend classic symbolic execution techniques for error detection of programs manipulating lists in loops. The idea is to enhance the symbolic execution with the utilization of quantitative aspect of the shape, and to construct the exit state of the loop. The exit state is constrained by a set of numeric constraints containing normal symbolic variables in programs and instrumented symbolic variables on the shapes. A prototype tool has been implemented and experiments are conducted on some commonly used list manipulating programs.


10.29007/c7v2 ◽  
2018 ◽  
Author(s):  
Matthias Kuntz ◽  
Stefan Leue ◽  
Christoph Scheben

Currently, there are no approaches known that allow for non-termination proofs of concurrent programs which account for asynchronous communication via FIFO message queues. Those programs may be written in high-level languages such as Java or Promela. We present a first approach to prove non-termination for such programs. In addition to integers, the programs that we consider may contain queues as data structures. We present a representation of queues and the operations on them in the domain of integers, and generate invariants that help us prove non-termination of selected control flow loops using a theorem proving approach. We illustrate this approach by applying a prototype tool implementation to a number of case studies.


1996 ◽  
Vol 06 (04) ◽  
pp. 451-467
Author(s):  
DANNY Z. CHEN ◽  
XIAOBO SHARON HU

The Parallel Priority Queue (PPQ) data structure supports parallel operations for manipulating data items with keys, such as inserting n new items, deleting n items with the first n smallest keys, creating a new PPQ that contains a set of items, and melding two PPQ’s into one. In this paper, we present fast and efficient parallel algorithms for performing operations on the PPQ’s that maintain data items with real-valued keys. The data structures that we use for implementing the PPQ’s are the unmeldable and meldable parallel heaps. Our algorithms have considerably less time and/or work bounds than the previously best known algorithms, and use a less powerful parallel computational model (EREW PRAM). The new ideas that make our improvement possible are two partition schemes dynamically maintained on the parallel heap structures: the minimal- path partition and the right-path partition. These partition schemes could be of interest in their own right. Our results also lead to optimal parallel algorithms for implementing sequential operations on several commonly-used heap structures.


Sign in / Sign up

Export Citation Format

Share Document