Data Oblivious Algorithms for Multicores

TL;DR

This paper develops data-oblivious algorithms optimized for realistic multicore processors using the binary fork-join model, achieving optimal or near-optimal efficiency for sorting and various graph algorithms, with practical implementation considerations.

Contribution

It introduces the first data-oblivious algorithms for multicores modeled by binary fork-join, matching or surpassing insecure algorithms in efficiency and providing practical variants.

Findings

Data-oblivious sorting achieves optimal work and cache complexity with O(log n log log n) span.

Applications like list ranking and minimum spanning forest have data-oblivious algorithms matching insecure counterparts.

Practical sorting variants are proposed with near-optimal performance and small constant factors.

Abstract

As secure processors such as Intel SGX (with hyperthreading) become widely adopted, there is a growing appetite for private analytics on big data. Most prior works on data-oblivious algorithms adopt the classical PRAM model to capture parallelism. However, it is widely understood that PRAM does not best capture realistic multicore processors, nor does it reflect parallel programming models adopted in practice. In this paper, we initiate the study of parallel data oblivious algorithms on realistic multicores, best captured by the binary fork-join model of computation. We first show that data-oblivious sorting can be accomplished by a binary fork-join algorithm with optimal total work and optimal (cache-oblivious) cache complexity, and in O(log n log log n) span (i.e., parallel time) that matches the best-known insecure algorithm. Using our sorting algorithm as a core primitive, we show how to data-obliviously simulate general PRAM algorithms in the binary fork-join model with non-trivial efficiency. We also present results for several applications including list ranking, Euler tour, tree contraction, connected components, and minimum spanning forest. For a subset of these applications, our data-oblivious algorithms asymptotically outperform the best known insecure algorithms. For other applications, we show data oblivious algorithms whose performance bounds match the best known insecure algorithms. Complementing these asymptotically efficient results, we present a practical variant of our sorting algorithm that is self-contained and potentially implementable. It has optimal caching cost, and it is only a log log n factor off from optimal work and about a log n factor off in terms of span; moreover, it achieves small constant factors in its bounds.