Differential D43319 Diff 139604 MicroBenchmarks/LCALS/LCALSTraversalMethods.cxx

Changeset View

Standalone View

MicroBenchmarks/LCALS/LCALSTraversalMethods.cxx

				//
				// See README-LCALS_license.txt for access and distribution restrictions
				//

				//
				// Source file containing LCALS traversal method implementations
				// used in forall-hybrid loop variants.
				//

				#include "LCALSTraversalMethods.hxx"

				#include <iostream>


				/*
				*************************************************************************
				*
				* HybridIndexSet class dtor.
				*
				*************************************************************************
				*/
				HybridIndexSet::~HybridIndexSet()
				{
				const int num_segs = m_segments.size();
				for ( int isi = 0; isi < num_segs; ++isi ) {
				Segment& seg = m_segments[isi];

				switch ( seg.m_type ) {

				case _Range_ : {
				if ( seg.m_segment ) {
				RangeIndexSet* is =
				const_cast<RangeIndexSet*>(
				static_cast<const RangeIndexSet*>(seg.m_segment)
				);
				delete is;
				}
				break;
				}

				case _RangeStride_ : {
				if ( seg.m_segment ) {
				RangeStrideIndexSet* is =
				const_cast<RangeStrideIndexSet*>(
				static_cast<const RangeStrideIndexSet*>(seg.m_segment)
				);
				delete is;
				}
				break;
				}

				default : {
				std::cout << "\t HybridIndexSet dtor: case not implemented!!\n";
				}

				} // iterate over segments of hybrid index set
				}
				}


				/*
				*************************************************************************
				*
				* Private helper function to copy hybrid index set segments.
				*
				*************************************************************************
				*/
				void HybridIndexSet::copySegments(const HybridIndexSet& other)
				{
				const int num_segs = m_segments.size();
				for ( int isi = 0; isi < num_segs; ++isi ) {
				const Segment& seg = m_segments[isi];

				switch ( seg.m_type ) {

				case _Range_ : {
				addIndexSet(static_cast<const RangeIndexSet>(seg.m_segment));
				break;
				}

				case _RangeStride_ : {
				addIndexSet(static_cast<const RangeStrideIndexSet>(seg.m_segment));
				break;
				}

				default : {
				std::cout << "\t HybridIndexSet copySegments: case not implemented!!\n";
				}

				} // iterate over segments of hybrid index set
				}
				}


				/*
				*************************************************************************
				*
				* Methods to add indices to hybrid index set.
				*
				*************************************************************************
				*/

				void HybridIndexSet::addIndexSet(const RangeIndexSet& index_set)
				{
				RangeIndexSet* new_is =
				new RangeIndexSet(index_set.getBegin(), index_set.getEnd());
				m_segments.push_back( Segment( _Range_, new_is ) );

				m_len += new_is->getLength();
				}

				void HybridIndexSet::addRangeIndices(Index_type begin, Index_type end)
				{
				RangeIndexSet* new_is = new RangeIndexSet(begin, end);
				m_segments.push_back( Segment( _Range_, new_is ) );

				m_len += new_is->getLength();
				}

				void HybridIndexSet::addIndexSet(const RangeStrideIndexSet& index_set)
				{
				RangeStrideIndexSet* new_is =
				new RangeStrideIndexSet(index_set.getBegin(), index_set.getEnd(),
				index_set.getStride());
				m_segments.push_back( Segment( _RangeStride_, new_is ) );

				m_len += new_is->getLength() / new_is->getStride();
				}

				void HybridIndexSet::addRangeStrideIndices(Index_type begin, Index_type end,
				Index_type stride)
				{
				RangeStrideIndexSet* new_is = new RangeStrideIndexSet(begin, end, stride);
				m_segments.push_back( Segment( _RangeStride_, new_is ) );

				m_len += new_is->getLength() / new_is->getStride();
				}