tools.cpp

Go to the documentation of this file.

/*
---------------------------------------------------------------------------

    This file is part of uHAL.

    uHAL is a hardware access library and programming framework
    originally developed for upgrades of the Level-1 trigger of the CMS
    experiment at CERN.

    uHAL 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 3 of the License, or
    (at your option) any later version.

    uHAL is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with uHAL.  If not, see <http://www.gnu.org/licenses/>.

      Marc Magrans de Abril, CERN
      email: marc.magrans.de.abril <AT> cern.ch

      Andrew Rose, Imperial College, London
      email: awr01 <AT> imperial.ac.uk

      Tom Williams, Rutherford Appleton Laboratory, Oxfordshire
      email: tom.williams <AT> cern.ch

---------------------------------------------------------------------------
*/

#include "uhal/tests/tools.hpp"


#include <fcntl.h>
#include <vector>

#include "uhal/ProtocolPCIe.hpp"
#include "uhal/tests/DummyHardware.hpp"


namespace uhal {
namespace tests {


DummyHardwareRunner::DummyHardwareRunner(DummyHardwareInterface* aHw) :
  mHw(aHw),
  mHwThread(boost::bind(&DummyHardwareInterface::run, aHw))
{
}

DummyHardwareRunner::~DummyHardwareRunner()
{
  mHw->stop();
  mHwThread.join();
}

void DummyHardwareRunner::setReplyDelay(const boost::chrono::microseconds& aDelay)
{
  mHw->setReplyDelay(aDelay);
}


double measureReadLatency(ClientInterface& aClient, uint32_t aBaseAddr, uint32_t aDepth, size_t aNrIterations, bool aDispatchEachIteration, bool aVerbose)
{
  return measureReadLatency(std::vector<ClientInterface*>(1, &aClient), aBaseAddr, aDepth, aNrIterations, aDispatchEachIteration, aVerbose);
}


double measureReadLatency(const std::vector<ClientInterface*>& aClients, uint32_t aBaseAddr, uint32_t aDepth, size_t aNrIterations, bool aDispatchEachIteration, bool aVerbose)
{
  typedef std::vector<ClientInterface*>::const_iterator ClientIterator_t;
  Timer myTimer;

  for ( unsigned i = 0; i < aNrIterations ; ++i )
  {
    if ( aVerbose )
    {
      std::cout << "Iteration " << i << std::endl;
    }

    for (ClientIterator_t lIt = aClients.begin(); lIt != aClients.end(); lIt++)
    {
      (*lIt)->readBlock ( aBaseAddr, aDepth, defs::NON_INCREMENTAL );
    }

    if ( aDispatchEachIteration )
    {
      for (ClientIterator_t lIt = aClients.begin(); lIt != aClients.end(); lIt++)
      {
        (*lIt)->dispatch();
      }
    }
  }

  if ( !aDispatchEachIteration )
  {
    for (ClientIterator_t lIt = aClients.begin(); lIt != aClients.end(); lIt++)
    {
      (*lIt)->dispatch();
    }
  }

  return myTimer.elapsedSeconds();
}


double measureWriteLatency(ClientInterface& aClient, uint32_t aBaseAddr, uint32_t aDepth, size_t aNrIterations, bool aDispatchEachIteration, bool aVerbose)
{
  return measureWriteLatency(std::vector<ClientInterface*>(1, &aClient), aBaseAddr, aDepth, aNrIterations, aDispatchEachIteration, aVerbose);
}


double measureWriteLatency(const std::vector<ClientInterface*>& aClients, uint32_t aBaseAddr, uint32_t aDepth, size_t aNrIterations, bool aDispatchEachIteration, bool aVerbose)
{
  typedef std::vector<ClientInterface*>::const_iterator ClientIterator_t;

  // Send buffer - lots of "cafebabe" (in little-endian)
  std::vector<uint32_t> sendBuffer ( aDepth, 0xbebafeca );
  Timer myTimer;

  for ( unsigned i = 0; i < aNrIterations ; ++i )
  {
    if ( aVerbose )
    {
      std::cout << "Iteration " << i << std::endl;
    }

    // Create the packet
    for (ClientIterator_t lIt = aClients.begin(); lIt != aClients.end(); lIt++)
    {
      (*lIt)->writeBlock ( aBaseAddr, sendBuffer, defs::NON_INCREMENTAL );
    }

    if ( aDispatchEachIteration )
    {
      for (ClientIterator_t lIt = aClients.begin(); lIt != aClients.end(); lIt++)
      {
        (*lIt)->dispatch();
      }
    }
  }

  if ( !aDispatchEachIteration )
  {
    for (ClientIterator_t lIt = aClients.begin(); lIt != aClients.end(); lIt++)
    {
      (*lIt)->dispatch();
    }
  }

  return myTimer.elapsedSeconds();
}


double measureFileReadLatency(const std::string& aFilePath, uint32_t aBaseAddr, uint32_t aDepth, size_t aNrIterations, bool aVerbose)
{
  PCIe::File lFile(aFilePath, O_RDWR | O_NONBLOCK);
  lFile.open();

  std::vector<uint32_t> lRecvBuffer;
  lFile.read(aBaseAddr, aDepth, lRecvBuffer);
  lRecvBuffer.clear();
  
  Timer myTimer;
  for ( unsigned i = 0; i < aNrIterations ; ++i )
  {
    if ( aVerbose )
    {
      std::cout << "Iteration " << i << std::endl;
    }

    lFile.read(aBaseAddr, aDepth, lRecvBuffer);
    lRecvBuffer.clear();
  }

  return myTimer.elapsedSeconds();
}


double measureFileWriteLatency(const std::string& aFilePath, uint32_t aBaseAddr, uint32_t aDepth, size_t aNrIterations, bool aVerbose)
{
  PCIe::File lFile(aFilePath, O_RDWR);
  std::vector<uint32_t> lSendBuffer(aDepth, 0x0);
  lFile.write(aBaseAddr, lSendBuffer);

  Timer myTimer;
  for ( unsigned i = 0; i < aNrIterations ; ++i )
  {
    if ( aVerbose )
    {
      std::cout << "Iteration " << i << std::endl;
    }

    lFile.write(aBaseAddr, lSendBuffer);
  }

  return myTimer.elapsedSeconds();
}


} // end ns tests
} // end ns uhal