Paraformance 
ParaFormance is a software tool-chain that allows software developers to quickly and easily write multi-core software. ParaFormance enables software developers to find the sources of parallelism within their code, automatically (through user-controlled guidance) inserting the parallel business logic, and checking that the parallelised code is thread-safe. 
  • ParaFormance works with C and C++
  • ParaFormance works on source code and is compiler independent
  • ParaFormance checks code for correctness - automatically - and highlights potential issues
  • ParaFormance detects candidates for parallelization within sequential code using extremely sophisticated pattern analysis and recognition
  • ParaFormance suggests code repairs and fixes for parallelism, enabling them to be implemented automatically or with developer intervention
  • ParaFormance enables roll-back of any changes to code
​

QA-Verify
QA·Verify’s client-server architecture and web-based interface combines the analysis strength and depth of QA·C and QA·C++ with team-sharing collaboration and broader quality management concepts. This solution appeals to audiences beyond core traditional developers to encompass stakeholders such as development leads, architects, project managers and senior management. With QA·Verify, team-based collaboration is fully embraced. Developers share a consistent view of source merged with detailed diagnostics for current or any past version of code. Additional comments and actions can be stored against any code artifact for forensic detailed code inspections. Controlled deviations from particular coding rules can be permitted through a sophisticated, fl exible system of suppressions. Baselining provides a mechanism to apply different coding rules to fi eld-proven legacy code versus new code. Integration into the Version Control System gives access to historic snapshots, enabling diagnostic comparison and metric trending across project timelines.

Fastflow
FastFlow (快速流) is a C++ parallel programming framework advocating high-level, pattern-based parallel programming. It chiefly supports streaming and data parallelism, targeting heterogenous platforms composed of clusters of shared-memory platforms, possibly equipped with computing accelerators such as NVidia GPGPUs, Xeon Phi, Tilera TILE64.
The main design philosophy of FastFlow is to provide application designers with key features for parallel programming (e.g. time-to-market, portability, efficiency and performance portability) via suitable parallel programming abstractions and a carefully designed run-time support.

Explisat

ExpliSAT is a tool for C/C++ software formal verification. It supports C90, C99, C11, C++03, and C++11. ExpliSAT is a symbolic interpreter, which executes the program with symbolic inputs representing all possible values the input can take. ExpliSAT is capable of detecting violations of user-defined assertions or existence of some generic programming errors (a.k.a built-in checks), or proving the absence of such violations or errors. Given a program (or function) under test, ExpliSAT explores each feasible execution path of a program, and if no path violating the error condition found, proven correctness result is generated, otherwise the counterexample is generated. The counterexample is a C-source-code, encapsulating the concrete values for inputs that lead to the error, which can be compiled with the verified code and then executed for triggering an error.

​pHARDI

Parallel High Angular Resolution Diffusion Imaging (pHARDI) is a toolkit for the GPU/CPU-accelerated reconstruction of intra-voxel reconstruction methods from diffusion Magnetic Resonance Imaging (dMRI) data. It was designed to support multiple linear algebra accelerators in a wide range of devices, such as multi-core GPU devices (both CUDA and OpenCL) or even co-processors, like Intel Xeon Phi. For platforms that do not support any GPU-based accelerator, our solution can also run on multi-core processors (CPU) using highly-tuned linear algebra libraries. We use Armadillo on top of the linear algebra accelerators for providing a common interface and ArrayFire for supporting GPU devices.

https://github.com/arcosuc3m/phardi

GrPPI

GrPPI is an open source generic and reusable parallel pattern programming interface developed at Univ. Carlos III of Madrid. Basically, GrPPI accommodates a layer between developers and existing parallel programming frameworks targeted to multi-core processors, such as ISO C++ Threads, OpenMP and Intel TBB, and accelerators. To achieve this goal, the interface leverages modern C++ features, meta-programming concepts, and template-based programming to act as switch between these frameworks. Furthermore, its compact design facilitates the development of parallel applications, hiding away the complexity behind the use of concurrency mechanisms. The parallel patterns supported by GrPPI are targeted for both stream processing and data-intensive applications and can be composed among them to match more complex constructions. In a nutshell, GrPPI advocates for a usable, simple, generic, and high-level parallel pattern interface, allowing users to implement parallel applications without having a deep understanding of today's parallel programming frameworks and third-party interfaces.

https://github.com/arcosuc3m/grppi


High Integrity C++ for Parallel and Concurrent Programming Coding Standard 
​


This document defines the rule set of the RePhrase C++ Coding Standard that facilitates parallel data-intensive software engineering. The guiding principles of this standard are maintenance, portability, readability and robustness. Justifications with examples of compliant and/or non-compliant code are provided for each rule. Each rule shall be enforced unless a formal deviation is recorded (see Section 0.6).
This document is created as part of the EU funded project RePhrase (Refactoring Parallel Heterogeneous Resource-Aware Applications A Software Engineering Approach) with contributions from the project consor- tium members (University of St.Andrews, IBM Israel Science & Technology Ltd., Software Competence Centre Hagenberg, Universidad Carlos III de Madrid, Centro de Investigacion Biomedica en Red de Salud Mental, University of Pisa, EvoPro Innovation, Programming Research Ltd., University of Torino).
The RePhrase project aims to make use of the functionality for multi-threading and parallel programming through the use of patterns. These patterns may also have common pitfalls which appropriate guidelines can help mitigate against.
This standard adopts the view that restrictions should be placed on the use of the ISO C++ language (see 1.1.1) without sacrificing its core flexibility. This approach allows for the creation of robust and easy to main- tain programs while minimizing problems created either by compiler diversity, different programming styles, or dangerous/confusing aspects of the language.
Without applying good coding standards, programmers may write code that is prone to bugs or difficult for someone else to pick up and maintain.
A combination of techniques has to be applied to achieve high integrity software: e.g. requirements man- agement and coverage testing. Only a few of such techniques are programming language specific, of which language subsetting is widely regarded as an effective and scalable method. When rigorously enforced, and coupled with language agnostic techniques, it can facilitate production of high integrity C++ code for parallel and concurrent programming. 

​
hicppmp.pdf
File Size: 599 kb
File Type: pdf
Download File
THE REPHRASE PROJECT
Copyright © 2018