SoDaBase.hxx

Go to the documentation of this file.

/*
Copyright (c) 2012,2013,2014 Matthew H. Reilly (kb1vc)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

    Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
    Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in
    the documentation and/or other materials provided with the
    distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef SODA_BASE_HDR
#define SODA_BASE_HDR

#include "Command.hxx"
#include "MultiMBox.hxx"
#include "Debug.hxx"
#include <complex>
#include <string>
#include <boost/thread.hpp>
#include <boost/format.hpp>
#include <sys/types.h>
#include <unistd.h>
#include <sys/syscall.h>

extern "C" {
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
}

namespace SoDa {

  class SoDaBuf : public MBoxMessage {
  public:
    SoDaBuf(unsigned int _size) {
      maxlen = _size;
      len = maxlen;
      dat = new std::complex<float>[_size];
      // we also overlay a floating point buffer in the same space.
      fdat = (float *) dat; 
      maxflen = maxlen * 2;
      flen = len * 2; 
    }

    bool copy(SoDaBuf * src) {
      if(maxlen >= src->maxlen) {
    flen = src->flen;
    memcpy(fdat, src->fdat, sizeof(float) * flen);
    return true; 
      }
      else {
    return false; 
      }
    }
    
    unsigned int getComplexLen() { return len; }
    unsigned int getComplexMaxLen() { return maxlen; }
    
    unsigned int getFloatLen() { return flen; }
    unsigned int getFloatMaxLen() { return maxflen; }

    bool setComplexLen(unsigned int nl) {
      if(nl > maxlen) return false; 
      len = nl;
      return true; 
    }
    
    bool setFloatLen(unsigned int nl) {
      if(nl > maxflen) return false; 
      flen = nl;
      return true; 
    }

    std::complex<float> * getComplexBuf() { return dat; }
    float * getFloatBuf() { return fdat; }
    
  private:
    std::complex<float> * dat; 
    float * fdat;              
    unsigned int maxflen;      
    unsigned int flen;         
    unsigned int maxlen;       
    unsigned int len;          
  };

  typedef MultiMBox<Command> CmdMBox;
  typedef MultiMBox<SoDaBuf> DatMBox;


  class SoDaBase {
  public:
    SoDaBase(const std::string & oname);

    std::string & getObjName() { return objname; }

    SoDaBase * findSoDaObject(const std::string & oname); 

    double getTime(); 

  private:
    std::string objname; 

    static bool first_time; 
    static double base_first_time; 

    static std::map<std::string, SoDaBase * > ObjectDirectory; 
  };

  class SoDaException { 
  public:
    SoDaException(const std::string & _reason, SoDaBase * obj = NULL) 
    {
      thrower = obj;
      reason = _reason; 
    }
    SoDaException(const char * _reason, SoDaBase * obj) {
      thrower = obj;
      reason = std::string(_reason); 
    }


    std::string toString() {
      std::string ret; 
      if(thrower != NULL) {
    ret = (boost::format("SoDa Object [%s] threw exception [%s]\n") % thrower->getObjName() % reason).str();
      }
      else {
    ret = (boost::format("Unknown SoDa Object threw exception [%s]\n") % reason).str();
      }

      return ret;
    }

    const char * what() {
      return toString().c_str();
    }
  private:
    SoDaBase * thrower; 
    std::string reason; 
  };


  class SoDaThread : public SoDaBase, public Debug {
  public:
    SoDaThread(const std::string & oname) : SoDaBase(oname), Debug(oname) {
      th = NULL; 
    }
    void start() {
      if(th != NULL) return;
      th = new boost::thread(&SoDaThread::outerRun, this);
    }

    void join() {
      th->join(); 
    }

    bool waitForJoin(unsigned int m) {
      return th->try_join_for(boost::chrono::milliseconds(m)); 
    }



    virtual void run() = 0;

    void execCommand(Command * cmd) 
    {
      switch (cmd->cmd) {
      case Command::GET:
    execGetCommand(cmd); 
    break;
      case Command::SET:
    execSetCommand(cmd); 
    break; 
      case Command::REP:
    execRepCommand(cmd); 
    break;
      default:
    break; 
      }
    }

    virtual void execGetCommand(Command * cmd) { (void) cmd; }

    virtual void execSetCommand(Command * cmd) { (void) cmd; }

    virtual void execRepCommand(Command * cmd) { (void) cmd; } 

  private:
    boost::thread * th;


    void outerRun() {
      hookSigSeg();
      pid_t tid;
      tid = syscall(SYS_gettid);
      debugMsg(boost::format("%s starting as TID %x.\n") % getObjName() % tid); 
      try {
    run(); 
      }
      catch (SoDaException exc) {
    std::cerr << getObjName() << " caught " << exc.toString() << std::endl;
      }
      catch (SoDaException * exc) {
    std::cerr << getObjName() << " caught " << exc->toString() << std::endl;
      }
      catch (const std::exception & e) {
    std::cerr << getObjName() << " caught exception here: " << e.what() << std::endl; 
      }
      catch (...) {
    std::cerr << getObjName() << " caught unknown exception" << std::endl;
      }
      debugMsg(boost::format("%s terminating.\n") % getObjName()); 
    }

    static void sigsegHandler(int sig)
    {
      std::cerr << "\n-----------"
        << "\n-----------"
        << "\n-----------"
        << "\n-----------"
        << " A SoDaThread caught a sig segv"
        << "\n-----------"
        << "\n-----------"
        << "\n-----------"
        << "\n-----------"
        << std::endl;
      // resignal
      signal(sig, SIG_DFL);
      kill(getpid(), SIGSEGV);
    }

    void hookSigSeg() {
      struct sigaction act;
      sigemptyset(&act.sa_mask);
      act.sa_handler = SoDaThread::sigsegHandler;
      act.sa_flags = 0;
      sigaction(SIGSEGV, &act, 0);
    }
    
  }; 
}

#endif