UnloaderShare.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/Pulsar/dsp/UnloaderShare.h
 
#ifndef __UnloaderShare_h
#define __UnloaderShare_h
 
#include "dsp/PhaseSeriesUnloader.h"
#include "dsp/SignalPath.h"
#include "dsp/TimeDivide.h"
 
class ThreadContext;
 
namespace dsp {
 
  class PhaseSeries;
  class PhaseSeriesUnloader;
 
 
  class UnloaderShare : public Reference::Able {
 
  public:
 
    UnloaderShare (unsigned contributors);
    
    virtual ~UnloaderShare ();
 
    void set_context (ThreadContext*);
 
    void set_wait_all (bool);
 
    class Submit;
 
    Submit* new_Submit (unsigned contributor);
 
    void unload (const PhaseSeries*, Submit*);
 
    void finish_all (unsigned contributor);
 
    void copy (const TimeDivide*);
 
    void set_start_time (const MJD& start_time);
 
    MJD get_start_time () const;
 
    void set_subint_seconds (double subint_seconds);
 
    double get_subint_seconds () const;
 
    void set_subint_turns (unsigned subint_turns);
 
    unsigned get_subint_turns () const;
 
 
    void set_unloader (PhaseSeriesUnloader* unloader);
 
    PhaseSeriesUnloader* get_unloader () const;
 
    void finish ();
 
  protected:
 
    class Storage;
 
    void unload (Storage*);
 
    void nonblocking_unload (unsigned istore, Submit*);
 
    std::vector< Reference::To<Storage> > storage;
 
    Reference::To<PhaseSeriesUnloader> unloader;
    
    TimeDivide divider;
 
    const TimeDivide* divider_copy;
 
    unsigned contributors;
 
    std::vector<uint64_t> last_division;
 
    ThreadContext* context;
 
    bool wait_all;
 
    std::vector<bool> finished_all;
 
    bool all_finished ();
  };
 
  class UnloaderShare::Submit : public PhaseSeriesUnloader
  {
  public:
 
    Submit (UnloaderShare* parent, unsigned contributor);
 
    Submit* clone () const;
 
    void set_unloader (PhaseSeriesUnloader* unloader);
 
    void unload (const PhaseSeries*);
 
    void partial (const PhaseSeries*);
 
    void finish ();
 
    void set_minimum_integration_length (double seconds);
 
    void set_cerr (std::ostream& os) const;
 
  protected:
 
    friend class UnloaderShare;
 
    Reference::To<UnloaderShare> parent;
    Reference::To<PhaseSeriesUnloader> unloader;
    unsigned contributor;
  };
 
  class UnloaderShare::Storage : public Reference::Able
  {
  public:
 
    Storage (unsigned contributors, const std::vector<bool>& finished);
 
    ~Storage ();
 
    void set_profiles (const PhaseSeries*);
 
    PhaseSeries* get_profiles ();
 
    void set_division (uint64_t);
 
    uint64_t get_division ();
 
    bool integrate (unsigned contributor, uint64_t division, const PhaseSeries*);
 
    void set_finished (unsigned contributor);
 
    bool get_finished ();
 
    void wait_all (ThreadContext*);
 
  protected:
 
    Reference::To<PhaseSeries> profiles;
 
    std::vector<bool> finished;
    uint64_t division;
 
    void print_finished ();
 
  };
 
}
 
#endif // !defined(__UnloaderShare_h)