39 research outputs found
GraphSE: An Encrypted Graph Database for Privacy-Preserving Social Search
In this paper, we propose GraphSE, an encrypted graph database for online
social network services to address massive data breaches. GraphSE preserves
the functionality of social search, a key enabler for quality social network
services, where social search queries are conducted on a large-scale social
graph and meanwhile perform set and computational operations on user-generated
contents. To enable efficient privacy-preserving social search, GraphSE
provides an encrypted structural data model to facilitate parallel and
encrypted graph data access. It is also designed to decompose complex social
search queries into atomic operations and realise them via interchangeable
protocols in a fast and scalable manner. We build GraphSE with various
queries supported in the Facebook graph search engine and implement a
full-fledged prototype. Extensive evaluations on Azure Cloud demonstrate that
GraphSE is practical for querying a social graph with a million of users.Comment: This is the full version of our AsiaCCS paper "GraphSE: An
Encrypted Graph Database for Privacy-Preserving Social Search". It includes
the security proof of the proposed scheme. If you want to cite our work,
please cite the conference version of i
Schnelle Löser fĂŒr partielle Differentialgleichungen
The workshop Schnelle LoÌser fuÌr partielle Differentialgleichungen, organised by Randolph E. Bank (La Jolla), Wolfgang Hackbusch(Leipzig), Gabriel Wittum (Heidelberg) was held May 22nd - May 28th, 2005. This meeting was well attended by 47 participants with broad geographic representation from 9 countries and 3 continents. This workshop was a nice blend of researchers with various backgrounds
GPRM: a high performance programming framework for manycore processors
Processors with large numbers of cores are becoming commonplace. In order to utilise the
available resources in such systems, the programming paradigm has to move towards increased parallelism. However, increased parallelism does not necessarily lead to better performance. Parallel programming models have to provide not only flexible ways of defining
parallel tasks, but also efficient methods to manage the created tasks. Moreover, in a general-purpose system, applications residing in the system compete for the shared resources. Thread
and task scheduling in such a multiprogrammed multithreaded environment is a significant challenge.
In this thesis, we introduce a new task-based parallel reduction model, called the Glasgow Parallel Reduction Machine (GPRM). Our main objective is to provide high performance while maintaining ease of programming. GPRM supports native parallelism; it provides a modular way of expressing parallel tasks and the communication patterns between them. Compiling a GPRM program results in an Intermediate Representation (IR) containing useful information about tasks, their dependencies, as well as the initial mapping information. This compile-time information helps reduce the overhead of runtime task scheduling and is key to high performance. Generally speaking, the granularity and the number of tasks are major factors in achieving high performance. These factors are even more important in the case of GPRM, as it is highly dependent on tasks, rather than threads.
We use three basic benchmarks to provide a detailed comparison of GPRM with Intel OpenMP, Cilk Plus, and Threading Building Blocks (TBB) on the Intel Xeon Phi, and with GNU OpenMP on the Tilera TILEPro64. GPRM shows superior performance in almost all cases, only by controlling the number of tasks. GPRM also provides a low-overhead mechanism, called âGlobal Sharingâ, which improves performance in multiprogramming situations.
We use OpenMP, as the most popular model for shared-memory parallel programming as the main GPRM competitor for solving three well-known problems on both platforms: LU factorisation of Sparse Matrices, Image Convolution, and Linked List Processing. We focus on proposing solutions that best fit into the GPRMâs model of execution. GPRM outperforms OpenMP in all cases on the TILEPro64. On the Xeon Phi, our solution for the LU Factorisation results in notable performance improvement for sparse matrices with large numbers of small blocks. We investigate the overhead of GPRMâs task creation and distribution for very short computations using the Image Convolution benchmark. We show that this overhead can be mitigated by combining smaller tasks into larger ones. As a result, GPRM can outperform OpenMP for convolving large 2D matrices on the Xeon Phi. Finally, we demonstrate that our parallel worksharing construct provides an efficient solution for Linked List processing and performs better than OpenMP implementations on the Xeon Phi.
The results are very promising, as they verify that our parallel programming framework for manycore processors is flexible and scalable, and can provide high performance without
sacrificing productivity
An Active-Library Based Investigation into the Performance Optimisation of Linear Algebra and the Finite Element Method
In this thesis, I explore an approach called "active libraries". These are libraries that take
part in their own optimisation, enabling both high-performance code and the presentation of
intuitive abstractions.
I investigate the use of active libraries in two domains. Firstly, dense and sparse linear algebra,
particularly, the solution of linear systems of equations. Secondly, the specification and solution
of finite element problems.
Extending my earlier (MEng) thesis work, I describe the modifications to my linear algebra
library "Desola" required to perform sparse-matrix code generation. I show that optimisations
easily applied in the dense case using code-transformation must be applied at a higher level of
abstraction in the sparse case. I present performance results for sparse linear system solvers
generated using Desola and compare against an implementation using the Intel Math Kernel
Library. I also present improved dense linear-algebra performance results.
Next, I explore the active-library approach by developing a finite element library that captures
runtime representations of basis functions, variational forms and sequences of operations between
discretised operators and fields. Using captured representations of variational forms and
basis functions, I demonstrate optimisations to cell-local integral assembly that this approach
enables, and compare against the state of the art.
As part of my work on optimising local assembly, I extend the work of Hosangadi et al. on
common sub-expression elimination and factorisation of polynomials. I improve the weight
function presented by Hosangadi et al., increasing the number of factorisations found. I present
an implementation of an optimised branch-and-bound algorithm inspired by reformulating the
original matrix-covering problem as a maximal graph biclique search problem. I evaluate the
algorithm's effectiveness on the expressions generated by our finite element solver
Applying Secure Multi-party Computation in Practice
In this work, we present solutions for technical difficulties in deploying secure multi-party computation in real-world applications. We will first give a brief overview of the current state of the art, bring out several shortcomings and address them.
The main contribution of this work is an end-to-end process description of deploying secure multi-party computation for the first large-scale registry-based statistical study on linked databases. Involving large stakeholders like government institutions introduces also some non-technical requirements like signing contracts and negotiating with the Data Protection Agency
Theoretical and practical efficiency aspects in cryptography
EThOS - Electronic Theses Online ServiceGBUnited Kingdo
Abstractions and performance optimisations for finite element methods
Finding numerical solutions to partial differential equations (PDEs) is an essential task in the discipline of scientific computing.
In designing software tools for this task, one of the ultimate goals is to balance the needs for generality, ease to use and high performance.
Domain-specific systems based on code generation techniques,
such as Firedrake,
attempt to address this problem with a design consisting of
a hierarchy of abstractions,
where the users can specify the mathematical problems via a high-level,
descriptive interface,
which is progressively lowered through the intermediate abstractions.
Well-designed abstraction layers are essential to enable performing code transformations and optimisations robustly and efficiently,
generating high-performance code without user intervention.
This thesis discusses several topics on the design of the abstraction layers of Firedrake,
and presents the benefit of its software architecture by providing examples of various optimising code transformations at the appropriate abstraction layers.
In particular, we discuss the advantage of describing the local assembly stage of a finite element solver in an intermediate representation based on symbolic tensor algebra.
We successfully lift specific loop optimisations,
previously implemented by rewriting ASTs of the local assembly kernels, to this higher-level tensor language,
improving the compilation speed and optimisation effectiveness.
The global assembly phase involves the application of local assembly kernels on a collection of entities of an unstructured mesh.
We redesign the abstraction to express the global assembly loop nests
using tools and concepts based on the polyhedral model.
This enables us to implement the cross-element vectorisation algorithm that delivers stable vectorisation performance on CPUs automatically.
This abstraction also improves the portability of Firedrake,
as we demonstrate targeting GPU devices transparently from the same software stack.Open Acces