source: icXML/icXML-devel/src/icxmlc/XMLLineColTracker.hpp @ 2720

/*
 *  Copyright © 2012 International Characters.
 *  This software is licensed to the public under the Open Software License 3.0.
 *  icXML is a trademark of International Characters.
 */

/*
 * @author Nigel Medforth, nigelm -at- interational-characters.com
 * @version $Id: XMLLineColTracker.hpp 207 2012-12-02 20:38:22Z robc $
 *
 */

/*  Parallel Bitwise Tracking of Line Number/Column Number */

#if !defined(XERCESC_INCLUDE_GUARD_XMLLINECOLTRACKER_HPP)
#define XERCESC_INCLUDE_GUARD_XMLLINECOLTRACKER_HPP

#include <icxmlc/clog2.h>
#include <simd-lib/bitblock.hpp>
#include <icxmlc/PopCounter.hpp>
#include <icxmlc/BitTracker.hpp>
#include <icxmlc/XMLConfig.hpp>

XERCES_CPP_NAMESPACE_BEGIN

class XMLLineColTracker
{
  public:

                XMLLineColTracker();

                XMLLineColTracker(const XMLLineColTracker&);

                void set(const XMLFileLoc line, const XMLFileLoc column);

                void next(const BitBlock newLine, const BitBlock skipMask);

                XMLLineColTracker& operator=(const XMLLineColTracker& tracker);

                void advance();

                void get
                (
                        const unsigned int     position
                        , XMLFileLoc         & line
                        , XMLFileLoc         & column
                );

                void get
                (
                        XMLFileLoc           & line
                        , XMLFileLoc         & column
                );

  private:

                XMLFileLoc calculateSkipCount(const unsigned int position);


                // TODO: if this is just a temporary storage line/col tracker,
                // have popcounter set to 0 to eliminate the tally bit blocks?
                BitBlock                      _currentLine;
                PopCounter<3>                 _line;
                BitTracker                    _column;
                BitBlock                      _currentSkipMask;
                PopCounter<1>                 _skip;
                BitBlock                      _initialPartialSkipMask;
};

/// --------------------------------------------------------------------------- ///

IDISA_ALWAYS_INLINE
XMLLineColTracker::XMLLineColTracker()
        : _currentLine(simd<1>::constant<0>())
        , _line()
        , _column()
        , _currentSkipMask(simd<1>::constant<0>())
        , _skip()
        , _initialPartialSkipMask(simd<1>::constant<0>())
{

}

/// --------------------------------------------------------------------------- ///

IDISA_ALWAYS_INLINE
XMLLineColTracker::XMLLineColTracker(const XMLLineColTracker & tracker)
        : _currentLine(tracker._currentLine)
        , _line(tracker._line)
        , _column(tracker._column)
        , _currentSkipMask(tracker._currentSkipMask)
        , _skip(tracker._skip)
        , _initialPartialSkipMask(tracker._initialPartialSkipMask)
{

}

/// --------------------------------------------------------------------------- ///

IDISA_ALWAYS_INLINE
XMLLineColTracker& XMLLineColTracker::operator=(const XMLLineColTracker& tracker)
{
        _currentLine = tracker._currentLine;
        _line = tracker._line;
        _column = tracker._column;
        _currentSkipMask = tracker._currentSkipMask;
        _skip = tracker._skip;
        _initialPartialSkipMask = tracker._initialPartialSkipMask;
        return *this;
}

/// --------------------------------------------------------------------------- ///

IDISA_ALWAYS_INLINE
void XMLLineColTracker::set(const XMLFileLoc line, const XMLFileLoc column)
{
        _currentLine = simd<1>::constant<0>();
        _line.set(line - 1);
        _column.set(column - 1);
        _currentSkipMask = simd<1>::constant<0>();
        _skip.set(0);
        _initialPartialSkipMask = simd<1>::constant<0>();
}

/// --------------------------------------------------------------------------- ///

IDISA_ALWAYS_INLINE
void XMLLineColTracker::next(const BitBlock newLine, const BitBlock skipMask)
{
        _currentLine = newLine;
        _currentSkipMask = skipMask;
}

/// --------------------------------------------------------------------------- ///

IDISA_ALWAYS_INLINE
void XMLLineColTracker::advance()
{
        if (_column.append(_currentLine))
        {
                // at least one new line exists in this block
                _line.tally(_currentLine);
                _initialPartialSkipMask = _currentSkipMask;
                _skip.set(0);
        }
        else
        {
                // no new lines exist in this block
                _skip.tally(_currentSkipMask);
        }
        _currentLine = simd<1>::constant<0>();
        _currentSkipMask = simd<1>::constant<0>();
}

/// --------------------------------------------------------------------------- ///

IDISA_ALWAYS_INLINE
void XMLLineColTracker::get
(
        XMLFileLoc           & line
        , XMLFileLoc         & column
)
{
        // count up how many column positions we skip up to and including this block
        const unsigned int dist = _column.distance();
        _skip.tally
        (
                simd_andc(_initialPartialSkipMask, mask_reverse_zeroes(dist & (BLOCK_SIZE - 1)))
        );
        _initialPartialSkipMask = simd<1>::constant<0>();
        // get the final line/column positions
        column = dist - _skip.count() + 1;
        line = _line.count() + 1;
}

/// --------------------------------------------------------------------------- ///

IDISA_ALWAYS_INLINE
void XMLLineColTracker::get
(
        const unsigned int     position
        , XMLFileLoc         & line
        , XMLFileLoc         & column
)
{
        const BitBlock partialBlockMask = mask_forward_zeroes(position);
        const BitBlock partialCurrentLine = simd_andc(_currentLine, partialBlockMask);
        const BitBlock partialSkipMask = simd_andc(_currentSkipMask, partialBlockMask);

        // data dependant but predictable condition
        if (bitblock::any(partialCurrentLine))
        {
                const unsigned int dist =
                        count_reverse_zeroes(partialCurrentLine);
                const uint64_t skipCount =
                        bitblock::popcount(simd_andc(partialSkipMask, mask_reverse_zeroes(dist)));
                // get the final line/column positions
                line = _line.count() + bitblock::popcount(partialCurrentLine) + 1;
                column = position + dist - BLOCK_SIZE + 1 - skipCount;
        }
        else // the last new line was in one of the previous blocks. find it.
        {
                const unsigned int dist = _column.distance();
                // count up how many column positions we skip up to this block
                _skip.tally
                (
                        simd_andc(_initialPartialSkipMask, mask_reverse_zeroes(dist & (BLOCK_SIZE - 1)))
                );
                _initialPartialSkipMask = simd<1>::constant<0>();
                // count how many column positions we skip within this block
                const uint64_t skipCount =
                        _skip.count() +
                        bitblock::popcount(partialSkipMask);
                // set the final line/column positions
                line = _line.count() + 1;
                column = dist + position - skipCount + 1;
        }
}

/// --------------------------------------------------------------------------- ///




XERCES_CPP_NAMESPACE_END

#endif