Working on linear solvers benchmark. (04cbac60) · Commits · TNL / tnl-dev

CMakeLists.txt

+5 −1

Original line number	Diff line number	Diff line
		@@ -140,6 +140,8 @@ endif()
		# Check for some system header
		#
		find_path( SYS_TIME_INCLUDE_DIR sys/time.h
		/usr/include/x86_64-linux-gnu
		/usr/include
		DOC "System timer headers." )
		if( ${SYS_TIME_INCLUDE_DIR} STREQUAL "SYS_TIME_INCLUDE_DIR-NOTFOUND" )
		message( "Missing header file sys/time.h" )
		@@ -150,6 +152,8 @@ else()
		endif()

		find_path( SYS_RESOURCE_INCLUDE_DIR sys/resource.h
		/usr/include/x86_64-linux-gnu
		/usr/include
		DOC "System resources headers." )
		if( ${SYS_RESOURCE_INCLUDE_DIR} STREQUAL "SYS_RESOURCE_INCLUDE_DIR-NOTFOUND" )
		message( "Missing header file sys/time.h" )

src/core/implementation/tnlArray.h

+4 −5

Original line number	Diff line number	Diff line
		@@ -47,11 +47,10 @@ template< typename Element,
		typename Index >
		tnlString tnlArray< Element, Device, Index > :: getType() const
		{
		return tnlString( "tnlArray< " ) +
		getParameterType< Element >() +
		Device :: getDeviceType() +
		getParameterType< Index >() +
		" >";
		return tnlString( "tnlArray< " ) + ", " +
		getParameterType< Element >() + ", " +
		Device :: getDeviceType() + ", " +
		getParameterType< Index >() + " >";
		};

		template< typename Element,

src/core/implementation/tnlSharedArray.h

deleted100644 → 0

+0 −294

Original line number	Diff line number	Diff line
		/***************************************************************************
		tnlSharedArray.h - description
		-------------------
		begin : Nov 7, 2012
		copyright : (C) 2012 by Tomas Oberhuber
		email : tomas.oberhuber@fjfi.cvut.cz
		***************************************************************************/

		/***************************************************************************
		* *
		* This program is free software; you can redistribute it and/or modify *
		* it under the terms of the GNU General Public License as published by *
		* the Free Software Foundation; either version 2 of the License, or *
		* (at your option) any later version. *
		* *
		***************************************************************************/

		#ifndef TNLSHAREDARRAY_H_IMPLEMENTATION
		#define TNLSHAREDARRAY_H_IMPLEMENTATION

		#include <core/tnlFile.h>
		#include <core/mfuncs.h>

		//namespace implementation
		//{

		template< typename Element,
		typename Device,
		typename Index >
		tnlSharedArray< Element, Device, Index > :: tnlSharedArray()
		: size( 0 ), data( 0 )
		{
		};

		template< typename Element,
		typename Device,
		typename Index >
		tnlString tnlSharedArray< Element, Device, Index > :: getType() const
		{
		return tnlString( "tnlSharedArray< " ) +
		getParameterType< Element >() +
		Device :: getDeviceType() +
		getParameterType< Index >() +
		" >";
		};

		template< typename Element,
		typename Device,
		typename Index >
		void tnlSharedArray< Element, Device, Index > :: bind( Element* data,
		const Index size )
		{
		tnlAssert( size >= 0,
		cerr << "You try to set size of tnlSharedArray to negative value."
		<< "Name: " << this -> getName() << endl
		<< "New size: " << size << endl );
		tnlAssert( data != 0,
		cerr << "You try to use null pointer to data for tnlSharedArray."
		<< "Name: " << this -> getName() );

		this -> size = size;
		this -> data = data;
		};

		template< typename Element,
		typename Device,
		typename Index >
		void tnlSharedArray< Element, Device, Index > :: bind( tnlArray< Element, Device, Index >& array )
		{
		this -> size = array. getSize();
		this -> data = array. getData();
		};

		template< typename Element,
		typename Device,
		typename Index >
		void tnlSharedArray< Element, Device, Index > :: bind( tnlSharedArray< Element, Device, Index >& array )
		{
		this -> size = array. getSize();
		this -> data = array. getData();
		};

		template< typename Element,
		typename Device,
		typename Index >
		void tnlSharedArray< Element, Device, Index > :: swap( tnlSharedArray< Element, Device, Index >& array )
		{
		swap( this -> size, array. size );
		swap( this -> data, array. data );
		};

		template< typename Element,
		typename Device,
		typename Index >
		void tnlSharedArray< Element, Device, Index > :: reset()
		{
		this -> size = 0;
		this -> data = 0;
		};

		template< typename Element,
		typename Device,
		typename Index >
		Index tnlSharedArray< Element, Device, Index > :: getSize() const
		{
		return this -> size;
		}

		template< typename Element,
		typename Device,
		typename Index >
		void tnlSharedArray< Element, Device, Index > :: setElement( const Element& x, Index i )
		{
		tnlAssert( 0 <= i && i < this -> getSize(),
		cerr << "Wrong index for setElement method in tnlSharedArray with name "
		<< this -> getName()
		<< " index is " << i
		<< " and array size is " << this -> getSize() );
		return Device :: setArrayElement( this -> data, x, i );
		};

		template< typename Element,
		typename Device,
		typename Index >
		Element tnlSharedArray< Element, Device, Index > :: getElement( Index i ) const
		{
		tnlAssert( 0 <= i && i < this -> getSize(),
		cerr << "Wrong index for getElement method in tnlSharedArray with name "
		<< this -> getName()
		<< " index is " << i
		<< " and array size is " << this -> getSize() );
		return Device :: getArrayElement( this -> data, i );
		};

		template< typename Element,
		typename Device,
		typename Index >
		Element& tnlSharedArray< Element, Device, Index > :: operator[] ( Index i )
		{
		tnlAssert( 0 <= i && i < this -> getSize(),
		cerr << "Wrong index for operator[] in tnlSharedArray with name "
		<< this -> getName()
		<< " index is " << i
		<< " and array size is " << this -> getSize() );
		// TODO: add static assert - this does not make sense for tnlCudaDevice
		return Device :: getArrayElementReference( this -> data, i );
		};

		template< typename Element,
		typename Device,
		typename Index >
		const Element& tnlSharedArray< Element, Device, Index > :: operator[] ( Index i ) const
		{
		tnlAssert( 0 <= i && i < this -> getSize(),
		cerr << "Wrong index for operator[] in tnlSharedArray with name "
		<< this -> getName()
		<< " index is " << i
		<< " and array size is " << this -> getSize() );
		// TODO: add static assert - this does not make sense for tnlCudaDevice
		return Device :: getArrayElementReference( this -> data, i );
		};

		template< typename Element,
		typename Device,
		typename Index >
		template< typename Array >
		tnlSharedArray< Element, Device, Index >& tnlSharedArray< Element, Device, Index > :: operator = ( const Array& array )
		{
		// TODO: check this
		/*STATIC_ASSERT( ElementType == Array :: ElementType &&
		IndexType == Array :: IndexType,
		"Cannot assign arrays with different element types or index types (in tnlSharedArray)" );*/
		tnlAssert( array. getSize() == this -> getSize(),
		cerr << "Source name: " << a. getName() << endl
		<< "Source size: " << a. getSize() << endl
		<< "Target name: " << this -> getName() << endl
		<< "Target size: " << this -> getSize() << endl );
		Device :: memcpy< Array :: ElementType,
		Array :: IndexType,
		Array :: DeviceType >
		( this -> getData(),
		array. getData(),
		array. getSize() );
		return ( *this );
		};

		template< typename Element,
		typename Device,
		typename Index >
		template< typename Array >
		bool tnlSharedArray< Element, Device, Index > :: operator == ( const Array& array ) const
		{
		// TODO: check this
		/*STATIC_ASSERT( ElementType == Array :: ElementType &&
		IndexType == Array :: IndexType,
		"Cannot assign arrays with different element types or index types (in tnlSharedArray)" );*/
		tnlAssert( array. getSize() == this -> getSize(),
		cerr << "Source name: " << a. getName() << endl
		<< "Source size: " << a. getSize() << endl
		<< "Target name: " << this -> getName() << endl
		<< "Target size: " << this -> getSize() << endl );
		return Device :: memcmp< Array :: ElementType,
		Array :: IndexType,
		Array :: DeviceType >
		( this -> getData(),
		array. getData(),
		array. getSize() );
		}

		template< typename Element,
		typename Device,
		typename Index >
		template< typename Array >
		bool tnlSharedArray< Element, Device, Index > :: operator != ( const Array& array ) const
		{
		// TODO: check this
		/*STATIC_ASSERT( ElementType == Array :: ElementType &&
		IndexType == Array :: IndexType,
		"Cannot assign arrays with different element types or index types (in tnlSharedArray)" );*/
		tnlAssert( array. getSize() == this -> getSize(),
		cerr << "Source name: " << a. getName() << endl
		<< "Source size: " << a. getSize() << endl
		<< "Target name: " << this -> getName() << endl
		<< "Target size: " << this -> getSize() << endl );
		return ! ( ( *this ) == array );
		}

		template< typename Element,
		typename Device,
		typename Index >
		void tnlSharedArray< Element, Device, Index > :: setValue( const Element& e )
		{
		tnlAssert( this -> size != 0,
		cerr << "Array name is " << this -> getName() );
		Device :: memset( this -> getData(), this -> getSize(), e );
		}

		template< typename Element,
		typename Device,
		typename Index >
		const Element* tnlSharedArray< Element, Device, Index > :: getData() const
		{
		return this -> data;
		}

		template< typename Element,
		typename Device,
		typename Index >
		Element* tnlSharedArray< Element, Device, Index > :: getData()
		{
		return this -> data;
		}

		template< typename Element,
		typename Device,
		typename Index >
		tnlSharedArray< Element, Device, Index > :: operator bool() const
		{
		return data != 0;
		};


		template< typename Element,
		typename Device,
		typename Index >
		template< typename IndexType2 >
		void tnlSharedArray< Element, Device, Index > :: touch( IndexType2 touches ) const
		{
		//TODO: implement
		};

		template< typename Element,
		typename Device,
		typename Index >
		bool tnlSharedArray< Element, Device, Index > :: save( tnlFile& file ) const
		{
		tnlAssert( this -> size != 0,
		cerr << "You try to save empty vector. Its name is " << this -> getName() );
		if( ! tnlObject :: save( file ) )
		return false;
		if( ! file. write( &this -> size, 1 ) )
		return false;
		if( ! file. write< Element, Device, Index >( this -> data, this -> size ) )
		{
		cerr << "I was not able to WRITE tnlSharedArray " << this -> getName()
		<< " with size " << this -> getSize() << endl;
		return false;
		}
		return true;
		};

		//}; // namespace implementation

		#endif /* TNLSHAREDARRAY_H_IMPLEMENTATION */

src/core/implementation/tnlSharedArray_impl.h

+4 −5

Original line number	Diff line number	Diff line
		@@ -38,11 +38,10 @@ template< typename Element,
		typename Index >
		tnlString tnlSharedArray< Element, Device, Index > :: getType() const
		{
		return tnlString( "tnlSharedArray< " ) +
		getParameterType< Element >() +
		Device :: getDeviceType() +
		getParameterType< Index >() +
		" >";
		return tnlString( "tnlSharedArray< " ) + ", " +
		getParameterType< Element >() + ", " +
		Device :: getDeviceType() + ", " +
		getParameterType< Index >() + " >";
		};

		template< typename Element,

src/core/implementation/tnlSharedVector.h

deleted100644 → 0

+0 −183

Original line number	Diff line number	Diff line
		/***************************************************************************
		tnlSharedVector.h - description
		-------------------
		begin : Nov 8, 2012
		copyright : (C) 2012 by Tomas Oberhuber
		email : tomas.oberhuber@fjfi.cvut.cz
		***************************************************************************/

		/***************************************************************************
		* *
		* This program is free software; you can redistribute it and/or modify *
		* it under the terms of the GNU General Public License as published by *
		* the Free Software Foundation; either version 2 of the License, or *
		* (at your option) any later version. *
		* *
		***************************************************************************/

		#ifndef TNLSHAREDVECTOR_H_IMPLEMENTATION
		#define TNLSHAREDVECTOR_H_IMPLEMENTATION

		#include <core/implementation/vector-operations.h>

		template< typename Real,
		typename Device,
		typename Index >
		tnlString tnlSharedVector< Real, Device, Index > :: getType() const
		{
		return tnlString( "tnlSharedVector< " ) +
		getParameterType< Real >() +
		Device :: getDeviceType() +
		getParameterType< Index >() +
		" >";
		};

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlSharedVector< Real, Device, Index > :: max() const
		{
		return getVectorMax( *this );
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlSharedVector< Real, Device, Index > :: min() const
		{
		return getVectorMin( *this );
		}


		template< typename Real,
		typename Device,
		typename Index >
		Real tnlSharedVector< Real, Device, Index > :: absMax() const
		{
		return getVectorAbsMax( *this );
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlSharedVector< Real, Device, Index > :: absMin() const
		{
		return getVectorAbsMin( *this );
		}

		template< typename Real,
		typename Device,
		typename Index >
		Real tnlSharedVector< Real, Device, Index > :: lpNorm( const Real& p ) const
		{
		return getVectorLpNorm( *this, p );
		}


		template< typename Real,
		typename Device,
		typename Index >
		Real tnlSharedVector< Real, Device, Index > :: sum() const
		{
		return getVectorSum( *this );
		}


		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		Real tnlSharedVector< Real, Device, Index > :: differenceMax( const Vector& v ) const
		{
		return getVectorDifferenceMax( *this, v );
		}


		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		Real tnlSharedVector< Real, Device, Index > :: differenceMin( const Vector& v ) const
		{
		return getVectorDifferenceMin( *this, v );
		}


		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		Real tnlSharedVector< Real, Device, Index > :: differenceAbsMax( const Vector& v ) const
		{
		return getVectorDifferenceAbsMax( *this, v );
		}

		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		Real tnlSharedVector< Real, Device, Index > :: differenceAbsMin( const Vector& v ) const
		{
		return getVectorDifferenceAbsMin( *this, v );
		}

		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		Real tnlSharedVector< Real, Device, Index > :: differenceLpNorm( const Vector& v, const Real& p ) const
		{
		return getVectorDifferenceLpNorm( *this, v, p );
		}


		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		Real tnlSharedVector< Real, Device, Index > :: differenceSum( const Vector& v ) const
		{
		return getVectorDifferenceSum( *this, v );
		}


		template< typename Real,
		typename Device,
		typename Index >
		void tnlSharedVector< Real, Device, Index > :: scalarMultiplication( const Real& alpha )
		{
		vectorScalarMultiplication( *this, alpha );
		}


		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		Real tnlSharedVector< Real, Device, Index > :: sdot( const Vector& v )
		{
		return getVectorSdot( *this, v );
		}


		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		void tnlSharedVector< Real, Device, Index > :: saxpy( const Real& alpha,
		const Vector& x )
		{
		vectorSaxpy( *this, x, alpha );
		}

		template< typename Real,
		typename Device,
		typename Index >
		template< typename Vector >
		void tnlSharedVector< Real, Device, Index > :: saxmy( const Real& alpha,
		const Vector& x )
		{
		vectorSaxmy( *this, x, alpha );
		}

		#endif /* TNLSHAREDVECTOR_H_IMPLEMENTATION */