All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Macros
Shared memory parallelization module

Classes

class  blaze::SerialSection< T >
 Section to enforce the serial execution of operations.The SerialSection class is an auxiliary helper class for the BLAZE_SERIAL_SECTION macro. It provides the functionality to detect whether a serial section is active, i.e. if the currently executed code is inside a serial section. More...
 

Macros

#define BLAZE_SERIAL_SECTION   if( blaze::SerialSection<int> serialSection = true )
 Section to enforce the serial execution of operations.This macro provides the option to start a serial section to enforce the serial execution of operations. The following example demonstrates how a serial section is used: More...
 

Dense matrix SMP functions

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpAssign (DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP assignment of a matrix to a dense matrix. More...
 
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpAddAssign (DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP addition assignment of a matrix to a dense matrix. More...
 
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpSubAssign (DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP subtraction assignment of a matrix to dense matrix. More...
 

Dense vector SMP functions

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpAssign (DenseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP assignment of a vector to a dense vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpAddAssign (DenseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP addition assignment of a vector to a dense vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpSubAssign (DenseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP subtraction assignment of a vector to a dense vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpMultAssign (DenseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP multiplication assignment of a vector to a dense vector. More...
 

Sparse matrix SMP functions

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpAssign (SparseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP assignment of a matrix to a sparse matrix. More...
 
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpAddAssign (SparseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP addition assignment of a matrix to a sparse matrix. More...
 
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpSubAssign (SparseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP subtraction assignment of a matrix to sparse matrix. More...
 

Sparse vector SMP functions

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpAssign (SparseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP assignment of a vector to a sparse vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpAddAssign (SparseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP addition assignment of a vector to a sparse vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpSubAssign (SparseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP subtraction assignment of a vector to a sparse vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpMultAssign (SparseVector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP multiplication assignment of a vector to a sparse vector. More...
 

SerialSection functions

bool blaze::isSerialSectionActive ()
 Returns whether a serial section is active or not. More...
 

Detailed Description

Macro Definition Documentation

#define BLAZE_SERIAL_SECTION   if( blaze::SerialSection<int> serialSection = true )

Section to enforce the serial execution of operations.This macro provides the option to start a serial section to enforce the serial execution of operations. The following example demonstrates how a serial section is used:

// ... Resizing and initialization
// Start of a serial section
// All operations executed within the serial section are guaranteed to be executed in
// serial (even if a parallel execution would be possible and/or beneficial).
x = A * b;
y = A * c;
z = A * d;
}

Note that it is not allowed to use nested serial sections (i.e. a serial section within another serial section). In case the nested use of a serial section is detected, a std::runtime_error exception is thrown.

Function Documentation

bool blaze::isSerialSectionActive ( )
inline

Returns whether a serial section is active or not.

Returns
true if a serial section is active, false if not.
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpAddAssign ( DenseVector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP addition assignment of a vector to a dense vector.

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side vector to be added.
Returns
void

This function implements the default SMP addition assignment of a vector to a dense vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpAddAssign ( SparseMatrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP addition assignment of a matrix to a sparse matrix.

Parameters
lhsThe target left-hand side sparse matrix.
rhsThe right-hand side matrix to be added.
Returns
void

This function implements the default SMP addition assignment of a matrix to a sparse matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpAddAssign ( DenseMatrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP addition assignment of a matrix to a dense matrix.

Parameters
lhsThe target left-hand side dense matrix.
rhsThe right-hand side matrix to be added.
Returns
void

This function implements the default SMP addition assignment of a matrix to a dense matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpAddAssign ( SparseVector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP addition assignment of a vector to a sparse vector.

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side vector to be added.
Returns
void

This function implements the default SMP addition assignment of a vector to a sparse vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpAssign ( SparseVector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP assignment of a vector to a sparse vector.

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side vector to be assigned.
Returns
void

This function implements the default SMP assignment of a vector to a sparse vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpAssign ( SparseMatrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP assignment of a matrix to a sparse matrix.

Parameters
lhsThe target left-hand side sparse matrix.
rhsThe right-hand side matrix to be assigned.
Returns
void

This function implements the default SMP assignment of a matrix to a sparse matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpAssign ( DenseVector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP assignment of a vector to a dense vector.

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side vector to be assigned.
Returns
void

This function implements the default SMP assignment of a vector to a dense vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpAssign ( DenseMatrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP assignment of a matrix to a dense matrix.

Parameters
lhsThe target left-hand side dense matrix.
rhsThe right-hand side matrix to be assigned.
Returns
void

This function implements the default SMP assignment of a matrix to a dense matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpMultAssign ( SparseVector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP multiplication assignment of a vector to a sparse vector.

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side vector to be multiplied.
Returns
void

This function implements the default SMP multiplication assignment of a vector to a sparse vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpMultAssign ( DenseVector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP multiplication assignment of a vector to a dense vector.

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side vector to be multiplied.
Returns
void

This function implements the default SMP multiplication assignment of a vector to a dense vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpSubAssign ( DenseMatrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP subtraction assignment of a matrix to dense matrix.

Parameters
lhsThe target left-hand side dense matrix.
rhsThe right-hand side matrix to be subtracted.
Returns
void

This function implements the default SMP subtraction assignment of a matrix to a dense matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
void blaze::smpSubAssign ( SparseMatrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP subtraction assignment of a matrix to sparse matrix.

Parameters
lhsThe target left-hand side sparse matrix.
rhsThe right-hand side matrix to be subtracted.
Returns
void

This function implements the default SMP subtraction assignment of a matrix to a sparse matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpSubAssign ( DenseVector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP subtraction assignment of a vector to a dense vector.

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side vector to be subtracted.
Returns
void

This function implements the default SMP subtraction assignment of a vector to a dense vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::smpSubAssign ( SparseVector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP subtraction assignment of a vector to a sparse vector.

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side vector to be subtracted.
Returns
void

This function implements the default SMP subtraction assignment of a vector to a sparse vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.