We present the design and implementation of the Standard Template Adap- tive Parallel Library (stapl) pList, a parallel container that has the properties of a sequential list, but allows for scalable concurrent access when used in a paral- lel program. The stapl is a parallel programming library that extends C with support for parallelism. stapl provides a collection of distributed data structures (pContainers) and parallel algorithms (pAlgorithms) and a generic methodology for extending them to provide customized functionality. stapl pContainers are thread-safe, concurrent objects, providing appropriate interfaces (pViews) that can be used by generic pAlgorithms. The pList provides Standard Template Library (stl) equivalent methods, such as insert, erase, and splice, additional methods such as split, and efficient asyn- chronous (non-blocking) variants of some methods for improved parallel performance. List related algorithms such as list ranking, Euler Tour (ET), and its applications to compute tree based functions can be computed efficiently and expressed naturally using the pList. Lists are not usually considered useful in parallel algorithms because they do not allow random access to its elements. Instead, they access elements through a serializing traversal of the list. Our design of the pList, which consists of a collec- tion of distributed lists (base containers), provides almost random access to its base containers. The degree of parallelism supported can be tuned by setting the number of base containers. Thus, a key feature of the pList is that it offers the advantages of a classical list while enabling scalable parallelism. We evaluate the performance of the stapl pList on an IBM Power 5 cluster and on a CRAY XT4 massively parallel processing system. Although lists are generally not considered good data structures for parallel processing, we show that pList methods and pAlgorithms, and list related algorithms such as list ranking and ET technique operating on pLists provide good scalability on more than 16, 000 processors. We also show that the pList compares favorably with other dynamic data structures such as the pVector that explicitly support random access.

An Euler tour of a hypergraph is a closed walk that traverses every edge exactly once; if a hypergraph admits such a walk, then it is called eulerian. Although this notion is one of the progenitors of graph theory --- dating back to the eighteenth century --- treatment of this subject has only begun on hypergraphs in the last decade. Other authors have produced results about rank-2 universal cycles and 1-overlap cycles, which are equivalent to our definition of Euler tours. In contrast, an Euler family is a collection of nontrivial closed walks that jointly traverse every edge of the hypergraph exactly once and cannot be concatenated simply. Since an Euler tour is an Euler family comprising a single walk, having an Euler family is a weaker attribute than being eulerian; we call a hypergraph quasi-eulerian if it admits an Euler family. Due to a result of Lovász, it can be much easier to determine that some classes of hypergraphs are quasi-eulerian, rather than eulerian; in this thesis, we present some techniques that allow us to make the leap from quasi-eulerian to eulerian. A triple system of order n and index λ (denoted TS(n,λ)) is a 3-uniform hypergraph in which every pair of vertices lies together in exactly λ edges. A Steiner triple system of order n is a TS(n,1). We first give a proof that every TS(n,λ) with λ ⩾ 2 is eulerian. Other authors have already shown that every such triple system is quasi-eulerian, so we modify an Euler family in order to show that an Euler tour must exist. We then give a proof that every Steiner triple system (barring the degenerate TS(3,1)) is eulerian. We achieve this by first constructing a near-Hamilton cycle out of some of the edges, then demonstrating that the hypergraph consisting of the remaining edges has a decomposition into closed walks in which each edge is traversed exactly once. In order to extend these results on triple systems, we define a type of hypergraph called an ℓ-covering k-hypergraph, a k-uniform hypergraph in which every ℓ-subset of the vertices lie together in at least one edge. We generalize the techniques used earlier on TS(n,λ) with λ ⩾ 2 and define interchanging cycles. Such cycles allow us to transform an Euler family into another Euler family, preferably of smaller cardinality. We first prove that all 2-covering 3-hypergraphs are eulerian by starting with an Euler family that has the minimum cardinality possible, then demonstrating that if there are two or more walks in the Euler family, then we can rework two or more of them into a single walk. We then use this result to prove by induction that, for k ⩾ 3, all (k-1)-covering k-hypergraphs are eulerian. We attempt to extend these results further to all ℓ-covering k-hypergraphs for ℓ ⩾ 2 and k ⩾ 3. Using the same induction technique as before, we only need to give a result for 2-covering k-hypergraphs. We are able to use Lovász's condition and some counting techniques to show that these are all quasi-eulerian. Finally, we give some constructive results on hypergraphs with small edge cuts. There has been analogous work by other authors on hypergraphs with small vertex cuts. We reduce the problem of finding an Euler tour in a hypergraph to finding an Euler tour in each of the connected components of the edge-deleted subhypergraph, then show how these individual Euler tours can be concatenated.