We present new shared-memory parallel algorithms for the bi-core decomposition problem, which discovers dense subgraphs in bipartite graphs and is the bipartite analogue of the classic k-core decomposition problem. We develop a theoretically-efficient parallel bi-core decomposition algorithm that discovers a hierarchy by peeling vertices from the graph in parallel. Our algorithm improves the span (parallel running time) over the state-of-the-art parallel bi-core decomposition algorithm, while matching the state-of-the-art sequential algorithm in work. We additionally prove the bi-core decomposition problem to be P-complete, meaning that a polylogarithmic span solution is unlikely under standard assumptions. We also devise a theoretically-efficient parallel bi-core index structure to allow for fast parallel queries of vertices in given cores.Finally, we propose a novel practical optimization that prunes unnecessary computations, and we provide optimized parallel implementations of our bi-core decomposition algorithms that are scalable and fast. Using 30 cores with two-way hyper-threading, our implementation achieves up to a 4.9x speedup over the state-of-the-art parallel algorithm. Our parallel index structure can be constructed up to 27.7x faster than the state-of-the-art sequential counterpart. Due to the improved storage format of our index structure, our parallel queries are up to 116.3x faster than the state-of-the-art sequential queries.
We revisit the problem of building static hash tables on the GPU and present an efficient implementation of bucketed hash tables. By decoupling the probing scheme from the hash table in-memory representation, we offer an implementation where the number of probes and the bucket size are the only factors limiting performance. Our analysis sweeps through the hash table parameter space for two probing schemes: cuckoo and iceberg hashing. We show that a bucketed cuckoo hash table (BCHT) that uses three hash functions outperforms alternative methods that use iceberg hashing and a cuckoo hash table that uses a bucket size of one. At load factors as high as 0.99, BCHT enjoys an average probe count of 1.43 during insertion. Using three hash functions only, positive and negative queries require at most 1.39 and 2.8 average probes per key, respectively.
Similarity searching is a well-studied problem in trajectory processing, where given a query trajectory, one wants to report all trajectories in the database similar to the query. Several works have focused on developing near neighbor data structures for trajectories under various metrics, e.g., Hausdorff distance, Frechet distance, etc. However, all near-neighbor data structures for these metrics use space that is super-linear (and sometimes a high-degree polynomial) in the size of the trajectory database. With trajectory datasets getting larger everyday, these data structures may not fit in RAM, and are likely stored on disk. In order to avoid expensive disk-accesses for every query, a lightweight filter in RAM that reports YES when there is a trajectory in the database similar to the query, and NO otherwise, is highly desirable. Furthermore, A long-standing criticism of standard measures for trajectories is that they ignore the temporal aspect of time-stamped trajectories, which holds critical information. This work focuses on optimizing near neighbor data structures by addressing the two issues above. We present a data structure that preprocesses a database T of trajectories so that, given a query trajectory Q and a similarity factor 0 <= rho <= 1, it answers Yes or No to whether there is a trajectory in T that is rho-similar to Q. Similarity between two trajectories here is defined as the Hamming distance between their binary sketches obtained from certain 3D lifts of the trajectories, where the third dimension incorporates the temporal aspect. With respect to this similarity measure, the data structure has only false positives and no false negatives. We show via experiments that the data structure has fast construction and query time, and gives up to 95% space savings on the original datasets. Additionally, our experiments indicate low mismatch rates between our similarity measure and Hausdorff and SketchMin distances, showing that the new measure is meaningful. We conclude that our data structure can be used as part of a two-tiered system in conjunction with a near-neighbor data structure on disk.
Reconfigurable networks have traditionally suffered from long reconfiguration times due to hardware limitations. With the emergence of new technologies that can reconfigure on the order of nanoseconds, the Oblivious Reconfigurable Network (ORN) design paradigm has been proposed to take advantage of this new capability. Two of the most important performance metrics for network operators considering ORNs are latency and throughput, which are inherently opposed and thus lead to a tradeoff. Previously, we constructed two families of ORN designs, called EBS and VBS, and proved that together they achieve optimal maximum latency (up to a constant factor) for any given throughput value r. Unfortunately, both families are defined only for very restrictive network sizes, N. This poses a challenge for implementing networks based on these designs in practice, as it is unlikely that a given system will have a suitable size. In this work, we extend both EBS and VBS to any network size while minimizing the impact on maximum latency and throughput. We prove that the extended versions achieve optimal maximum latency for all sufficiently large N, except when the throughput r exactly equals the reciprocal of an even integer.
Network administrators are interested in measuring the distribution of delays (the time between a request and its response), by directly running succinct algorithms within high-speed network devices. Unfortunately, the considerable gap between the small available memory and the huge volume of arriving traffic makes it challenging to design an algorithm that accurately measures delays. Existing algorithms exhibit bias against samples with higher delays. We present fridges, a novel data structure that corrects for the survivorship bias due to hash collisions, producing unbiased estimates of the delay distribution. The key idea is to consider a sample that was lucky enough to survive many insertions into the data structure as a representative for other similar samples that did not survive. We also show how to combine results from multiple fridges, each optimized for a different range of delays, for further accuracy gains. Simulation experiments show our design outperforms prior work using naive hash-indexed arrays, achieving 2x-4x memory saving. We implement a prototype P4 program running on the Intel Tofino programmable switch, using only moderate hardware resources.
