pFaces is a generic Cloud-ready, multi-compute-platform, tool for accelerating parallel algorithms. Faces is an acceleration engine that works with kernels representing different software sections.


Accelerating software targeting all compute platforms: CPUs, GPUs, HW-Accelerators, Embedded systems, and Cloud Computing platforms.


A heterogenous compute model

Having a heterogenous compute platform of different compute nodes (CN), pFaces offers an all-you-can-use acceleration model.

It utilizes MPI for intra-node synchronization and OpenCL for low-level device-adapted computation.

Compute tasks are compiled on the file to suit the targeted HW device.

Targeted platforms:
CPUs, GPUs, HW-Accelerators (e.g., FPGAs), Embedded systems, and Cloud computing.

pFaces targets HW platforms formed by a network of heterogenous compute devices.

Extensible loadable compute kernels

The extensible design of pFaces allows handling loadable kernels that are remotely developed.

Users have the freedom to parallelize parts of their software via loadable execute kernels.

Kernels in pFaces are developed in C++ with OpenCL. pFaces offers a friendly SDK to build the kernels remotely (as dynamically loadable plugins) and then run them in pFaces deployments in several HW configurations.

pFaces then takes the effort of running the kernels efficiently on the targeted HW.


You control time

Experience orders of magnitude reductions in execution time as you add more resources, and as the problem complexity increases, compared to your traditional serial implementation.

We guide you design scalable algorithms to benefit from the diversity of compute resources available in your local devices or those we optimized in Cloud platforms.

As a result, you have the control over the time needed to solve your computation problem.

Clear reduction in computation time for constructing a finite-state model from a dynamical system. Refer to [2] for more details.


HPC-powered microservices

Although they lack required resources, some applications still need to solve some computationally intensive problems, possibly, in real-time. Rather than deploying expensive HW for each application, we help you deploy Cloud microservices that accelerates essential sections in your software.

Now, your application can rely on the remote HPC service and low-latency communication to solve problems that would never be solved locally in time.


After redesigning (some parts of) your software, pFaces let you deploy RESTFull interfaces to encapsulate the computation task within a deployable microservice.


Example case-studies

Here we show a self-driving car connected to a microservice deployed in the Cloud.

The accelerated task is a formally-verified controller for the car. Without acceleration, the task takes minutes to solve the correct-by-construction controller synthesis and code generation. With pFaces, it takes less than one second using a single GPU.

More case studies can be found in pFaces repository.


Try pFaces

For a locally-deployed demo version, visit pFaces’ GitHub repository.

Interested in giving the full version a test-drive in the Cloud ? Contact Us.


Resources

[1] Mahmoud Khaled and Majid Zamani. pFaces: An Acceleration Ecosystem for Symbolic Control. International Conference on Hybrid Systems: Computation and Control (HSCC) 2019.

[2] Mahmoud Khaled, Eric S Kim, Murat Arcak, and Majid Zamani. Synthesis of Symbolic Controllers: A Parallelized and Sparsity-Aware Approach. International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS) 2019.