dc_filterservice.h

Go to the documentation of this file.
00001 // -*- c++ -*-
00002 // ****************************************************************************
00003 //  Name: dc_filterservice.h
00004 //  Athr: Michael D. Beynon (mdb)
00005 //  Date: 08/05/1999 : mdb - Created.
00006 //        01/10/2002 : mdb - arg_t subclasses initarg_t to avoid duplication.
00007 //        01/23/2002 : mdb - Misc cleanups suggested by Umit.
00008 //  Desc: DataCutter Filter Service user library.
00009 // ****************************************************************************
00012 #if !defined(H_DC_FILTERSERVICE)
00013 #define H_DC_FILTERSERVICE
00014 
00015 #include <pthread.h>
00016 
00017 #include "lib/dc_standard.h"
00018 #include "lib/dc_argv.h"
00019 #include "lib/dc_configinfo.h"
00020 #include "lib/dc_socket.h"
00021 #include "lib/dc_memory.h"
00022 #include "lib/dc_map.h"
00023 #include "lib/dc_timer.h"
00024 #include "lib/dc_metric.h"
00025 #include "lib/dc_mutex.h"
00026 
00027 #include "dc_error.h"
00028 #include "dc_buffer.h"
00029 #include "dc_filterlayout.h"
00030 #include "dc_work.h"
00031 #include "dc_placement.h"
00032 
00033 // Forward Declarations
00034 class DC_FilterService_t; 
00035 class DC_PipeInStream_t;
00036 class DC_PipeOutStream_t;
00037 // From consoleprocessstate.h
00038 class DC_ConsoleProcessState;
00039 // From remoteprocessstate.h
00040 class DC_RemoteInStreamCopy;
00041 class DC_RemoteOutStreamCopy;
00042 class DC_RemoteFilterCopy;
00043 class DC_RemoteProcessState;
00044 // From thread-reader.h
00045 class DC_ReaderServerLoop;
00046 // From dc_instance.h
00047 class DC_FilterInstance_t;
00048 
00049 
00050 typedef void (*PerfCallback_f)(int inst, const char *sbFilterName,
00051                                int rank, double *sa, long *sal);
00052 extern PerfCallback_f g_fcnPerfCallback;
00053 
00054 
00055 // Supported return values for user-defined interface methods
00056 /*
00057  * These return values allow the filter to communicate with
00058  * the runtime system.  
00059  */
00060 typedef enum {
00061   DC_RTN_OK,     // Put EOW on stream, return DC_ERR_OK on WaitWork
00062   DC_RTN_CONT,   // Put EOW on stream, return DC_ERR_WorkFail on WaitWork
00063   // CLH - There's no way to kill off a filter and allow it's cohorts to continue
00064   // without a signifigant code overhaul, so this is on hold for the moment.
00065   //DC_RTN_TERM,   // Put EOS on stream, return DC_ERR_RemoteFilterFail on WaitWork, kill filter
00066   DC_RTN_ABRT    // Put EOS on stream, return DC_ERR_InstanceFail on WaitWork, kill group instance
00067 } DC_RTN_t;
00068 
00070 
00075 class DC_Filter_Base_t {
00076 public:
00077   DC_FilterService_t *pDC; 
00078   const char *sbFilterName;  
00079 
00081 
00094   class initarg_t {
00095     friend class DC_RemoteFilterCopy;
00096   protected:
00097     DC_RemoteFilterCopy *pFilter;
00098   public:
00099     int         argc;
00100     char      **argv;
00101     const char *sbFilterName, *sbFullName, *sbCopyName;
00102     DC_Work_t  *pwork;
00103 
00104     ~initarg_t(void);
00105 
00107     int rankWithinCopySet(void);
00109     int maxWithinCopySet(void);
00111     int rankCopySets(void);
00112 
00113     int maxCopySets(void);
00115     int rankCopies(void);
00116 
00117     int maxCopies(void);
00118   };
00119 
00121   class arg_t : public initarg_t {
00122     friend class DC_RemoteProcessState;
00123     friend class DC_FilterInstance_t;
00124     friend class DC_RemoteFilterCopy;
00125   protected:
00126     int _init(DC_RemoteFilterCopy *pFilter_in, DC_FilterService_t *pDC);
00127     int _resetInsEOW(void);
00128     int DrainInput(int wWorkNum);
00129 
00130   public:
00131     arg_t(void);
00132     ~arg_t(void);
00133 
00134     int                 nins;
00135     DC_PipeInStream_t  *ins;
00136     int                 nouts;
00137     DC_PipeOutStream_t *outs;
00138 
00140     int insIndex(char *sbName);  
00142     int outsIndex(char *sbName); 
00144     DC_PipeInStream_t  *insLookup(char *sbName);  
00146     DC_PipeOutStream_t *outsLookup(char *sbName); 
00148     DC_Buffer_t *insReadAny(int *piFound = NULL, bool *rgStreamSet = NULL);
00150     int insNumEOW(void);
00152     bool insAllEOW(void);
00154     int CloseOutputWaitInput(int wWorkNum, bool fEndOfWork=false);
00155   };
00156 
00157 public:
00158   DC_Filter_Base_t(void) : pDC(NULL), sbFilterName(NULL) {};
00159   // 11/29/2001 : mdb - (Umit found) sbFilterName ptr is shared, don't delete
00160   virtual ~DC_Filter_Base_t(void) {};
00161 
00163   // (do not call in ctor -- pDC is NULL until first init() call)
00164   char *FindAppFilterConfig(const char *sbName, int wId = -1);
00165   long FindAppFilterConfigInt(const char *sbName, 
00166                               int wId = -1,
00167                               bool fInterpretUnits = true);
00168   double FindAppFilterConfigDbl(const char *sbName, int wId = -1);
00169 
00171   void FilterLock(void);
00173   void FilterUnlock(void);
00174 
00176   virtual DC_RTN_t init(initarg_t &arg) = 0;
00178   virtual DC_RTN_t process(arg_t &arg) = 0;
00180   virtual DC_RTN_t finalize(void) = 0;
00181 };
00182 
00184 
00188 class DC_Policy_Base_t {
00189 public:
00197   virtual int write_copyset(int wMax, char *sbStream,
00198                             DC_Buffer_t *pbuf, void *pUserArg) {
00199     return 0;
00200   };
00201 };
00202 
00204 
00209 class DC_PipeInStream_t {
00210   friend class DC_RemoteProcessState;
00211   friend class DC_RemoteFilterCopy;
00212   friend class DC_Filter_Base_t::arg_t;
00213 private:
00214   DC_RemoteFilterCopy   *pFilter;
00215   DC_RemoteInStreamCopy *pInStream;
00216   bool fEOW;  // T==EOW buffer was read by user from stream
00217   bool fEOS;  // T==EOS buffer was read by user from stream
00218   DC_FilterService_t *pDC;
00219 
00220   DC_Buffer_t *read_u(void);
00221 
00222 public:
00223   char *getName(void);
00224   bool isEndOfWork(void) { return fEOW; };
00225   bool isEndOfStream(void) { return fEOS; };
00226 
00227   DC_Buffer_t *read(void);
00228   int close(void);
00229 };
00230 
00232 
00265 class DC_PipeOutStream_t {
00266   friend class DC_RemoteProcessState;
00267   friend class DC_RemoteFilterCopy;
00268   friend class DC_Filter_Base_t::arg_t;
00269 private:
00270   DC_RemoteFilterCopy    *pFilter;
00271   DC_RemoteOutStreamCopy *pOutStream;
00272   bool fEOW;  
00273   bool fEOS;  
00274   DC_FilterService_t *pDC;
00275 
00276 public:
00277   char *getName(void);
00278   bool isEndOfWork(void) { return fEOW; };
00279   bool isEndOfStream(void) { return fEOS; };
00280 
00281   int write(DC_Buffer_t *pbuf, void *pUserArg=NULL);
00282   inline int write(DC_Buffer_t &buf, void *pUserArg=NULL) {
00283     buf.setConsume(false);  // assume a static buf since not a ptr
00284     return write(&buf, pUserArg);
00285   }
00286   int write_nocopy(DC_Buffer_t *pbuf, void *pUserArg=NULL);
00292   inline int write_nocopy(DC_Buffer_t &buf, void *pUserArg=NULL) {
00293     buf.setConsume(false);  // assume a static buf since not a ptr
00294     return write_nocopy(&buf, pUserArg);
00295   }
00296   int close(bool fEndOfWork=false);
00297 };
00298 
00299 
00300 
00301 
00303 
00306 class DC_FilterService_t {
00307   friend class DC_ConsoleProcessState;
00308   friend class DC_FilterInstance_t;
00309   friend class DC_RemoteProcessState;
00310   friend class DC_RemoteFilterCopy;
00311   friend class DC_ReaderServerLoop;
00312   friend class DC_PipeOutStream_t;
00313   friend class DC_PipeInStream_t;
00314 public:
00315   typedef DC_Filter_Base_t *(*FilterFactory_f)(char *);
00316   typedef DC_Policy_Base_t *(*PolicyFactory_f)(char *);
00317 
00318 protected:
00319   char *sbAppName;
00320   int *pargc;
00321   char ***pargv;
00322   FilterFactory_f fcnFilterFactory;
00323   PolicyFactory_f fcnPolicyFactory;
00324     
00325     
00326   DC_ConsoleProcessState *pConsole;
00327   DC_RemoteProcessState  *pRemote;
00328   DC_ReaderServerLoop    *pReader;
00329 
00330   // common reader state
00331   InetAddress  addrReader;  
00332   ClientSocket sockReader;
00333 
00334   InetAddress  addrLocal;  
00335   ServerSocket sockLocal;
00336 
00338   DC_Mutex mutexFilterInternal;
00339 
00341   bool fCalledRun;
00342 
00343 private:
00344   char *_ArgvNextExtract(int *pargc, char ***pargv, char *sbFlag);
00345   char *FindParm(ConfigInfo &cfg, char *sbSection, char *sbName,
00346                  bool fExitNotFound=true);
00347   int _ProcessSpecs(ConfigInfo &cfg);
00348   int _ProcessPeerLibSpecs(ConfigInfo &cfg);
00349   int _ConsoleNode(void);
00350   Types::uint find_filter(char *sbName);
00351   Types::uint _FindFilterByTid(pthread_t tid);
00352 
00358   ConfigInfo cfgConsole;
00359 
00360 public:
00361   DC_FilterService_t(void);
00362   ~DC_FilterService_t(void);
00363 
00364   int init(char *sbAppName_in, 
00365            FilterFactory_f fcnFilterFactory_in,
00366            int *pargc, 
00367            char ***pargv,
00368            PerfCallback_f fcnPerfCallback_in = NULL);
00369 
00370   void setPolicyFactory(PolicyFactory_f fcnPolicyFactory_in);
00371 
00372   bool isRemoteProcess(void) { return (pConsole == NULL); };
00373 
00374   int RemoteProcess(void);
00375 
00376   char *getAppName(void) const { return sbAppName; };
00377 
00378   int PlacementPlanning(DC_FilterLayout_t &layout, DC_Work_t &work,
00379                         DC_Placement_t &placement);
00380 
00381   int ReuseFilterInstance(DC_FilterLayout_t &layout, DC_Work_t &work,
00382                           DC_Placement_t &placement,
00383                           DC_FilterInstance_t *pinstance);
00384   int NewFilterInstance(DC_FilterLayout_t &layout, DC_Work_t &work,
00385                         DC_Placement_t &placement,
00386                         DC_FilterInstance_t *&pinstance);
00387   int GetFilterInstance(DC_FilterLayout_t &layout, DC_Work_t &work,
00388                         DC_Placement_t &placement,
00389                         DC_FilterInstance_t *&pinstance);
00390   int StopFilterInstance(DC_FilterInstance_t *&pinstance, bool fWait=true);
00391 
00392     
00393   // check status of a piece of work
00394   int ProbeWork(DC_WorkHandle_t wh, int *status);
00395     
00397   int WaitWork(DC_WorkHandle_t wh);
00398 
00399   //int WaitAllWork(void); // wait for all appended work to finish
00400   //int WaitAllWork(DC_FilterInstance_t &*pinstance);
00401 
00403   DC_WorkHandle_t WaitAnyWork(void);
00404 
00405   //DC_WorkHandle_t DC.WaitAnyWork(DC_FilterInstance_t &*pinstance);
00406 
00407   int ExitStatus(DC_WorkHandle_t wh);
00408 
00409   void FilterLock(void);
00410 
00411   void FilterUnlock(void);
00412 
00413 #if 0 // TODO: come back and re-implement this
00414   int ConsolePrintf(char *sbFormat, ...);
00415   int ConsoleOutput(MemoryBuf *pbuf, bool fLock=true);
00416   int ConsoleOutput(MemoryBuf &buf, bool fLock=true) {
00417     return ConsoleOutput(&buf, fLock);
00418   };
00419 #endif
00420 
00422   char *FindAppConfig(const char *sbName, const char *sbFilterName=NULL,
00423                       int wId=-1);
00424 
00426   long FindAppConfigInt(const char *sbName, const char *sbFilterName=NULL,
00427                         int wId=-1, bool fInterpretUnits=true);
00428 
00430   double FindAppConfigDbl(const char *sbName, const char *sbFilterName=NULL,
00431                           int wId=-1);
00432 };
00433 
00434 #endif /* H_DC_FILTERSERVICE */
00435 // ****************************************************************************

Generated at Mon Mar 3 13:53:21 2003 for DataCutter by doxygen1.2.8.1 written by Dimitri van Heesch, © 1997-2001