CubeDataThreadTester.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "CubeDataThreadTester.h"
 
#include <iostream>
 
#include <QMap>
#include <QMutex>
#include <QReadWriteLock>
#include <QPair>
#include <QVector>
 
#include "CubeDataThread.h"
#include "IString.h"
#include "FileName.h"
#include "Brick.h"
#include "Cube.h"
 
using namespace std;
using namespace Isis;
 
namespace Isis {
  CubeDataThreadTester::CubeDataThreadTester(CubeDataThread *testObject) :
    QThread() {
    p_cachedDoneBricks = NULL;
    p_cubeDataThread = testObject;
    p_numTestsDone = 0;
    p_execStarted = false;
    p_notifyDone = true;
 
    p_cachedDoneBricks = new QVector< QPair<int, const Isis::Brick *> >;
 
    start();
    moveToThread(this);
  }
 
 
  void CubeDataThreadTester::Connect() {
    connect(this,
            SIGNAL(RequestReadCube(int, int, int, int, int, int, void *)),
            p_cubeDataThread,
            SLOT(ReadCube(int, int, int, int, int, int, void *)));
 
    connect(this,
            SIGNAL(RequestReadWriteCube(int, int, int, int, int, int, void *)),
            p_cubeDataThread,
            SLOT(ReadWriteCube(int, int, int, int, int, int, void *)));
 
    connect(this, SIGNAL(NotifyDoneWithData(int, const Isis::Brick *)),
            p_cubeDataThread, SLOT(DoneWithData(int, const Isis::Brick *)));
 
    connect(p_cubeDataThread, SIGNAL(ReadReady(void *, int, const Isis::Brick *)),
            this, SLOT(ReadBrick(void *, int, const Isis::Brick *)));
 
    connect(p_cubeDataThread, SIGNAL(ReadWriteReady(void *, int, Isis::Brick *)),
            this, SLOT(ReadWriteBrick(void *, int, Isis::Brick *)));
  }
 
 
  CubeDataThreadTester::~CubeDataThreadTester() {
    if(!p_execStarted) {
      QThread::yieldCurrentThread();
    }
 
    QThread::exit(0);
 
    wait();
  }
 
  void CubeDataThreadTester::run() {
    p_execStarted = true;
    exec();
  }
 
  void CubeDataThreadTester::ReadCubeTest(int cubeId) {
    cout << "=============== Testing Basic Read ===============" << endl;
    emit RequestReadCube(cubeId, 1, 1, 2, 2, 1, this);
  }
 
 
  void CubeDataThreadTester::ReadCubeTest2(int cubeId1, int cubeId2) {
    cout << "=============== Testing Multiple Non-Conflicting Cube Reads " <<
         "===============" << endl;
 
    p_notifyDone = false;
    emit RequestReadCube(cubeId1, 1, 1, 3, 2, 1, this);
    emit RequestReadCube(cubeId2, 1, 2, 3, 2, 1, this);
  }
 
 
  void CubeDataThreadTester::ReadCubeTest3(int cubeId) {
    cout << "=============== Testing Exact Overlap Cube Reads ==============="
         << endl << endl;
 
    p_notifyDone = false;
    emit RequestReadCube(cubeId, 1, 2, 2, 2, 1, this);
    emit RequestReadCube(cubeId, 1, 2, 2, 2, 1, this);
  }
 
 
  void CubeDataThreadTester::WriteCubeTest(int cubeId) {
    cout << "=============== Testing Basic R/W ===============" << endl << endl;
    emit RequestReadWriteCube(cubeId, 1, 1, 2, 2, 1, this);
    emit RequestReadCube(cubeId, 1, 1, 2, 2, 1, this);
  }
 
 
  void CubeDataThreadTester::WriteCubeTest2(int cubeId1, int cubeId2) {
    cout << "=============== Testing Multiple Non-Conflicting Cube R/W " <<
         "===============" << endl << endl;
 
    p_notifyDone = false;
    emit RequestReadWriteCube(cubeId1, 1, 1, 3, 1, 1, this);
    emit RequestReadWriteCube(cubeId2, 1, 1, 3, 1, 1, this);
  }
 
 
  void CubeDataThreadTester::WriteCubeTest3(int cubeId) {
    cout << "=============== Testing Conflicting Cube R/W ==============="
         << endl;
 
    p_notifyDone = false;
    emit RequestReadWriteCube(cubeId, 1, 1, 3, 1, 1, this);
    emit RequestReadWriteCube(cubeId, 1, 1, 3, 1, 1, this);
  }
 
 
  void CubeDataThreadTester::WriteCubeTest3BreakDeadlock() {
    cout << "  Breaking Deadlock From Test 3" << endl;
    while(!p_cachedDoneBricks->size()) {
      msleep(100);
    }
 
    if(p_cachedDoneBricks->size()) {
      cout << "  Notify done with first brick" << endl;
      emit NotifyDoneWithData((*p_cachedDoneBricks)[0].first,
                              (*p_cachedDoneBricks)[0].second);
      p_cachedDoneBricks->clear();
    }
  }
 
 
  void CubeDataThreadTester::NotifyChangeTest(int cubeId) {
    cout << "=============== Testing Change Notification ==============="
         << endl;
 
    connect(p_cubeDataThread,
            SIGNAL(BrickChanged(int, const Isis::Brick *)),
            this,
            SLOT(BrickChanged(int, const Isis::Brick *))
           );
 
    p_cubeDataThread->AddChangeListener();
    emit RequestReadWriteCube(cubeId, 5, 1, 5, 1, 1, this);
  }
 
 
  void CubeDataThreadTester::ReadBrick(void *requester, int cubeId,
                                       const Isis::Brick *data) {
    cout << "  CubeDataThreadTester::ReadBrick" << endl;
 
    cout << "    Requester is me? " << ((this == requester) ? "Yes" : "No")
         << endl;
 
    if(this != requester) return;
 
    cout << "    Data:" << endl;
 
    for(int i = 0; i < data->size(); i++) {
      if(i == 0) cout << "      ";
      if(i % 6 == 6 - 1 && i != data->size() - 1) {
        cout << data->at(i) << endl << "      ";
      }
      else if(i == data->size() - 1) {
        cout << data->at(i) << endl;
      }
      else {
        cout << data->at(i) << "\t";
      }
    }
 
    cout << endl;
    if(p_notifyDone) {
      cout << "  Notify done with this brick" << endl;
      emit NotifyDoneWithData(cubeId, data);
 
      if(p_cachedDoneBricks->size()) {
        cout << "  Notify done with first brick" << endl;
        emit NotifyDoneWithData((*p_cachedDoneBricks)[0].first,
                                (*p_cachedDoneBricks)[0].second);
        p_cachedDoneBricks->clear();
      }
    }
    else {
      QPair<int, const Brick *> cache;
      cache.first = cubeId;
      cache.second = data;
 
      p_cachedDoneBricks->push_back(cache);
    }
 
    p_notifyDone = true;
    p_numTestsDone ++;
  }
 
  void CubeDataThreadTester::ReadWriteBrick(void *requester, int cubeId,
      Isis::Brick *data) {
    cout << "  CubeDataThreadTester::ReadWriteBrick" << endl;
 
    // This was a nice idea, but has race conditions that are difficult
    //   at best to resolve.
 
    //cout << "    Managed Bricks in Memory = " <<
    //  p_cubeDataThread->BricksInMemory() << endl;
 
    cout << "    Changing Brick : Index 0 Becoming 5" << endl;
    cout << endl;
 
    cout << "    Old Data: " << endl;
 
    for(int i = 0; i < data->size(); i++) {
      if(i == 0) cout << "      ";
      if(i % 6 == 6 - 1 && i != data->size() - 1) {
        cout << data->at(i) << endl << "      ";
      }
      else if(i == data->size() - 1) {
        cout << data->at(i) << endl;
      }
      else {
        cout << data->at(i) << "\t";
      }
    }
 
    (*data)[0] = 5;
 
    cout << "    New Data: " << endl;
 
    for(int i = 0; i < data->size(); i++) {
      if(i == 0) cout << "      ";
      if(i % 6 == 6 - 1 && i != data->size() - 1) {
        cout << data->at(i) << endl << "      ";
      }
      else if(i == data->size() - 1) {
        cout << data->at(i) << endl;
      }
      else {
        cout << data->at(i) << "\t";
      }
    }
 
    cout << endl;
 
    if(p_notifyDone) {
      cout << "  Notify done with this brick" << endl;
      emit NotifyDoneWithData(cubeId, data);
 
      if(p_cachedDoneBricks->size()) {
        cout << "  Notify done with first brick" << endl;
        emit NotifyDoneWithData((*p_cachedDoneBricks)[0].first,
                                (*p_cachedDoneBricks)[0].second);
        p_cachedDoneBricks->clear();
      }
    }
    else {
      QPair<int, const Brick *> cache;
      cache.first = cubeId;
      cache.second = data;
 
      p_cachedDoneBricks->push_back(cache);
    }
 
    p_notifyDone = true;
    p_numTestsDone ++;
  }
 
 
  void CubeDataThreadTester::BrickChanged(int cubeId, const Isis::Brick *data) {
    cout << "  CubeDataThreadTester::BrickChanged" << endl;
    cout << "    Data:" << endl;
 
    for(int i = 0; i < data->size(); i++) {
      if(i == 0) cout << "      ";
      if(i % 6 == 6 - 1 && i != data->size() - 1) {
        cout << data->at(i) << endl << "       ";
      }
      else if(i == data->size() - 1) {
        cout << data->at(i) << endl;
      }
      else {
        cout << data->at(i) << "\t";
      }
    }
 
    p_numTestsDone ++;
    emit NotifyDoneWithData(cubeId, data);
  }
};