testframe.cpp

Go to the documentation of this file.

/*
  TestFrame  -  test data frame (stub) for checking Render engine functionality
 
   Copyright (C)
     2011, 2024       Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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. See the file COPYING for further details.
 
* *****************************************************************/
 
#include "lib/error.hpp"
#include "lib/random.hpp"
#include "lib/hash-standard.hpp"
#include "lib/hash-combine.hpp"
#include "steam/engine/testframe.hpp"
#include "lib/nocopy.hpp"
#include "lib/util.hpp"
 
#include <climits>
#include <memory>
#include <deque>
 
 
 
namespace steam {
namespace engine{
namespace test  {
  namespace err = lumiera::error;
  
  using std::deque;
  using util::unConst;
  
  using PseudoRandom = lib::RandomSequencer<std::minstd_rand>;
  
  
  namespace { // hidden local support facilities....
    
    const size_t SEQUENCE_SPREAD = 100;
    
    HashVal
    drawSeed (lib::Random& srcGen)
    {
      return srcGen.distribute(
                std::uniform_int_distribution<HashVal>{SEQUENCE_SPREAD
                                                      ,std::numeric_limits<HashVal>::max()-SEQUENCE_SPREAD});
    }
    
    HashVal dataSeed{drawSeed(lib::entropyGen)};
    
    uint64_t
    generateDiscriminator(uint seq, uint family)
    {
      // use the family as stepping
      return (seq+1) * (dataSeed+family);
    }
    
    class DistinctNucleus
      : public lib::SeedNucleus
      , util::MoveOnly
      {
        uint64_t const& distinction_;
        
      public:
        DistinctNucleus(uint64_t const& anchor)
          : distinction_{anchor}
          { }
        
        uint64_t
        getSeed()  override
          {
            return distinction_;
          }
      };
    
    HashVal
    stampHeader()
    {
      static const HashVal MARK = lib::entropyGen.hash()
                                | 0b1000'1000'1000'1000'1000'1000'1000'1000;   
      return MARK;
    }
    
    auto
    buildDataGenFrom (uint64_t const& anchor)
    {
      DistinctNucleus seed{anchor};
      return PseudoRandom{seed};
    }
    
    
    TestFrame&
    accessAsTestFrame (void* memoryLocation)
    {
      REQUIRE (memoryLocation);
      return *reinterpret_cast<TestFrame*> (memoryLocation);
    }
    
    
    /* ======= static TestFrame repository ======= */
    
    struct TestFrameTable
      : deque<deque<TestFrame>>
      {
        TestFrameTable() = default;
        
        TestFrame&
        getFrame (uint seqNr, uint chanNr)
          {
            if (chanNr >= this->size())
                resize(chanNr+1);
            ENSURE (chanNr < this->size());
            deque<TestFrame>& channel = at(chanNr);
            
            if (seqNr >= channel.size())
              {
                INFO (test, "Growing channel #%d of test frames %d -> %d elements."
                          , chanNr, channel.size(), seqNr+1);
                for (uint nr=channel.size(); nr<=seqNr; ++nr)
                  channel.emplace_back (nr, chanNr);
              }
            ENSURE (seqNr < channel.size());
            return channel[seqNr];
          }
      };
      //
    std::unique_ptr<TestFrameTable> testFrames;
    //
  }// (End) hidden impl details
  
  
  
  
  TestFrame&
  testData (uint seqNr, uint chanNr)
  {
    if (not testFrames)
      testFrames = std::make_unique<TestFrameTable>();
    return testFrames->getFrame (seqNr, chanNr);
  }
 
  
  void
  TestFrame::reseed()
  {
    testFrames.reset(); // discard existing test data repository
    dataSeed = drawSeed (lib::defaultGen);
  }
  
  
  
  
  
  /* ======= TestFrame class ======= */
  
  TestFrame::Meta::Meta (uint seq, uint family)
    : _MARK_{stampHeader()}
    , checksum{0}
    , distinction{generateDiscriminator (seq,family)}
    , stage{CREATED}
    { }
  
  TestFrame::~TestFrame()
    {
      header_.stage = DISCARDED;
    }
  
  
  TestFrame::TestFrame (uint seq, uint family)
    : header_{seq,family}
    {
      buildData();
      ASSERT (0 < header_.distinction);
      ENSURE (CREATED == header_.stage);
      ENSURE (isPristine());
    }
  
  TestFrame::TestFrame (TestFrame const& o)
    : header_{o.header_}
    {
      data() = o.data();
      header_.stage = CREATED;
    }
  
  TestFrame&
  TestFrame::operator= (TestFrame const& o)
    {
      if (not isAlive())
        throw err::Logic ("target TestFrame already dead or unaccessible");
      if (not util::isSameAdr (this, o))
        {
          data() = o.data();
          header_ = o.header_;
          header_.stage = CREATED;
        }
      return *this;
    }
  
  
  bool
  TestFrame::Meta::isPlausible()  const
  {
    return _MARK_ == stampHeader()
       and stage <= DISCARDED;
  }
  
  TestFrame::Meta&
  TestFrame::accessHeader()
  {
    if (not header_.isPlausible())
      throw err::Invalid{"TestFrame: missing or corrupted metadata"};
    return header_;
  }
  TestFrame::Meta const&
  TestFrame::accessHeader()  const
  {
    return unConst(this)->accessHeader();
  }
  
  TestFrame::StageOfLife
  TestFrame::currStage()  const
  {
    return header_.isPlausible()? header_.stage
                                : DISCARDED;
  }
  
  bool
  TestFrame::Meta::operator== (Meta const&o)  const
  {
    return isPlausible() and o.isPlausible()
       and stage == o.stage
       and checksum == o.checksum
       and distinction == o.distinction;
  }
  
  bool
  TestFrame::operator== (void* memLocation)  const
  {
    TestFrame& candidate (accessAsTestFrame (memLocation));
    return candidate.isSane()
       and candidate == *this;
  }
 
  bool
  TestFrame::contentEquals (TestFrame const& o)  const
  {
    return data() == o.data();
  }
  
  
  void
  TestFrame::buildData()
  {
    auto gen = buildDataGenFrom (accessHeader().distinction);
    for (uint64_t& dat : data64())
      dat = gen.u64();
    markChecksum();
  }
  
  bool
  TestFrame::matchDistinction()  const
  {
    auto gen = buildDataGenFrom (accessHeader().distinction);
    for (uint64_t const& dat : data64())
      if (dat != gen.u64())
        return false;
    return true;
  }
  
  HashVal
  TestFrame::computeChecksum()  const
  {
    HashVal checksum{0};
    std::hash<char> getHash;
    for (char const& dat : data())
      lib::hash::combine (checksum, getHash (dat));
    return checksum;
  }
  
  HashVal
  TestFrame::markChecksum()
  {
    return accessHeader().checksum = computeChecksum();
  }
  HashVal
  TestFrame::getChecksum()
  {
    return accessHeader().checksum;
  }
  
  bool
  TestFrame::hasValidChecksum()  const
  {
    return accessHeader().checksum == computeChecksum();
  }
  
  bool
  TestFrame::isSane()  const
  {
    return header_.isPlausible();
  }
  
  bool
  TestFrame::isValid()  const
  {
    return isSane()
       and hasValidChecksum();
  }
  
  bool
  TestFrame::isPristine()  const
  {
    return isValid()
       and matchDistinction();
  }
  
  bool
  TestFrame::isAlive() const
  {
    return isSane()
       and not isDead();
  }
  
  bool
  TestFrame::isDead()  const
  {
    return isSane()
       and (DISCARDED == currStage());
  }
  
  bool
  TestFrame::isAlive (void* memLocation)
  {
    TestFrame& candidate (accessAsTestFrame (memLocation));
    return candidate.isAlive();
  }
  
  bool
  TestFrame::isDead (void* memLocation)
  {
    TestFrame& candidate (accessAsTestFrame (memLocation));
    return candidate.isDead();
  }
  
  
}}} // namespace steam::engine::test