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 // Supported return values for user-defined interface methods
00050 /* 
00051  * These return values allow the filter to communicate with
00052  * the runtime system.  Returning DC_RTN_EndOfFilter indicates that
00053  * the filter code should exit immediately, while DC_RTN_EndOfWork
00054  * indicates that filter can continue running to process further work 
00055  * assignments if available.  Filter functions can test whether the upstream 
00056  * filter exited normally by calling isEndOfWork() on its input stream(s).
00057  */
00058 typedef enum {
00059 //  DC_RTN_EndOfFilter = 0,
00060   DC_RTN_EndOfWork = 1
00061 } DC_RTN_t;
00062 
00064 
00069 class DC_Filter_Base_t {
00070 public:
00071   DC_FilterService_t *pDC; 
00072   const char *sbFilterName;  
00073 
00075 
00088   class initarg_t {
00089     friend class DC_RemoteFilterCopy;
00090   protected:
00091     DC_RemoteFilterCopy *pFilter;
00092   public:
00093     int         argc;
00094     char      **argv;
00095     const char *sbFilterName, *sbFullName, *sbCopyName;
00096     DC_Work_t  *pwork;
00097 
00098     ~initarg_t(void);
00099 
00101     int rankWithinCopySet(void);
00103     int maxWithinCopySet(void);
00105     int rankCopySets(void);
00106 
00107     int maxCopySets(void);
00109     int rankCopies(void);
00110 
00111     int maxCopies(void);
00112   };
00113 
00115   class arg_t : public initarg_t {
00116     friend class DC_RemoteProcessState;
00117     friend class DC_FilterInstance_t;
00118     friend class DC_RemoteFilterCopy;
00119   protected:
00120     int _init(DC_RemoteFilterCopy *pFilter_in, DC_FilterService_t *pDC);
00121     int _resetInsEOW(void);
00122     int DrainInput(int wWorkNum);
00123 
00124   public:
00125     arg_t(void);
00126     ~arg_t(void);
00127 
00128     int                 nins;
00129     DC_PipeInStream_t  *ins;
00130     int                 nouts;
00131     DC_PipeOutStream_t *outs;
00132 
00134     int insIndex(char *sbName);  
00136     int outsIndex(char *sbName); 
00138     DC_PipeInStream_t  *insLookup(char *sbName);  
00140     DC_PipeOutStream_t *outsLookup(char *sbName); 
00142     DC_Buffer_t *insReadAny(int *piFound = NULL, bool *rgStreamSet = NULL);
00144     int insNumEOW(void);
00146     bool insAllEOW(void);
00148     int CloseOutputWaitInput(int wWorkNum, bool fEndOfWork=false);
00149   };
00150 
00151 public:
00152   DC_Filter_Base_t(void) : pDC(NULL), sbFilterName(NULL) {};
00153   // 11/29/2001 : mdb - (Umit found) sbFilterName ptr is shared, don't delete
00154   virtual ~DC_Filter_Base_t(void) {};
00155 
00157   // (do not call in ctor -- pDC is NULL until first init() call)
00158   char *FindAppFilterConfig(const char *sbName, int wId = -1);
00159   long FindAppFilterConfigInt(const char *sbName, 
00160                               int wId = -1,
00161                               bool fInterpretUnits = true);
00162   double FindAppFilterConfigDbl(const char *sbName, int wId = -1);
00163 
00165   void FilterLock(void);
00167   void FilterUnlock(void);
00168 
00170   virtual int init(initarg_t &arg) = 0;
00172   virtual DC_RTN_t process(arg_t &arg) = 0;
00174   virtual int finalize(void) = 0;
00175 };
00176 
00178 
00182 class DC_Policy_Base_t {
00183 public:
00191   virtual int write_copyset(int wMax, char *sbStream,
00192                             DC_Buffer_t *pbuf, void *pUserArg) {
00193     return 0;
00194   };
00195 };
00196 
00198 
00203 class DC_PipeInStream_t {
00204   friend class DC_RemoteProcessState;
00205   friend class DC_RemoteFilterCopy;
00206   friend class DC_Filter_Base_t::arg_t;
00207 private:
00208   DC_RemoteFilterCopy   *pFilter;
00209   DC_RemoteInStreamCopy *pInStream;
00210   bool fEOW;  // T==EOW buffer was read by user from stream
00211   bool fEOS;  // T==EOS buffer was read by user from stream
00212   DC_FilterService_t *pDC;
00213 
00214   DC_Buffer_t *read_u(void);
00215 
00216 public:
00217   char *getName(void);
00218   bool isEndOfWork(void) { return fEOW; };
00219   bool isEndOfStream(void) { return fEOS; };
00220 
00221   DC_Buffer_t *read(void);
00222   int close(void);
00223 };
00224 
00226 
00259 class DC_PipeOutStream_t {
00260   friend class DC_RemoteProcessState;
00261   friend class DC_RemoteFilterCopy;
00262   friend class DC_Filter_Base_t::arg_t;
00263 private:
00264   DC_RemoteFilterCopy    *pFilter;
00265   DC_RemoteOutStreamCopy *pOutStream;
00266   bool fEOW;  
00267   bool fEOS;  
00268   DC_FilterService_t *pDC;
00269 
00270 public:
00271   char *getName(void);
00272   bool isEndOfWork(void) { return fEOW; };
00273   bool isEndOfStream(void) { return fEOS; };
00274 
00275   int write(DC_Buffer_t *pbuf, void *pUserArg=NULL);
00276   inline int write(DC_Buffer_t &buf, void *pUserArg=NULL) {
00277     buf.setConsume(false);  // assume a static buf since not a ptr
00278     return write(&buf, pUserArg);
00279   }
00280   int write_nocopy(DC_Buffer_t *pbuf, void *pUserArg=NULL);
00286   inline int write_nocopy(DC_Buffer_t &buf, void *pUserArg=NULL) {
00287     buf.setConsume(false);  // assume a static buf since not a ptr
00288     return write_nocopy(&buf, pUserArg);
00289   }
00290   int close(bool fEndOfWork=false);
00291 };
00292 
00294 
00297 class DC_FilterService_t {
00298   friend class DC_ConsoleProcessState;
00299   friend class DC_FilterInstance_t;
00300   friend class DC_RemoteProcessState;
00301   friend class DC_RemoteFilterCopy;
00302   friend class DC_ReaderServerLoop;
00303   friend class DC_PipeOutStream_t;
00304   friend class DC_PipeInStream_t;
00305 public:
00306   typedef DC_Filter_Base_t *(*FilterFactory_f)(char *);
00307   typedef DC_Policy_Base_t *(*PolicyFactory_f)(char *);
00308 
00309 protected:
00310   char *sbAppName;
00311   int *pargc;
00312   char ***pargv;
00313   FilterFactory_f fcnFilterFactory;
00314   PolicyFactory_f fcnPolicyFactory;
00315 
00316   DC_ConsoleProcessState *pConsole;
00317   DC_RemoteProcessState  *pRemote;
00318   DC_ReaderServerLoop    *pReader;
00319 
00320   // common reader state
00321   InetAddress  addrReader;  
00322   ClientSocket sockReader;
00323 
00324   InetAddress  addrLocal;  
00325   ServerSocket sockLocal;
00326 
00328   DC_Mutex mutexFilterInternal;
00329 
00331   bool fCalledRun;
00332 
00333 private:
00334   char *_ArgvNextExtract(int *pargc, char ***pargv, char *sbFlag);
00335   char *FindParm(ConfigInfo &cfg, char *sbSection, char *sbName,
00336                  bool fExitNotFound=true);
00337   int _ProcessSpecs(ConfigInfo &cfg);
00338   int _ProcessPeerLibSpecs(ConfigInfo &cfg);
00339   int _ConsoleNode(void);
00340   Types::uint find_filter(char *sbName);
00341   Types::uint _FindFilterByTid(pthread_t tid);
00342 
00348   ConfigInfo cfgConsole;
00349 
00350 public:
00351   DC_FilterService_t(void);
00352   ~DC_FilterService_t(void);
00353 
00354   int init(char *sbAppName_in, 
00355            FilterFactory_f fcnFilterFactory_in,
00356            int *pargc, 
00357            char ***pargv);
00358 
00359   void setPolicyFactory(PolicyFactory_f fcnPolicyFactory_in);
00360 
00361   bool isRemoteProcess(void) { return (pConsole == NULL); };
00362 
00363   int RemoteProcess(void);
00364 
00365   char *getAppName(void) const { return sbAppName; };
00366 
00367   int PlacementPlanning(DC_FilterLayout_t &layout, DC_Work_t &work,
00368                         DC_Placement_t &placement);
00369 
00370   int ReuseFilterInstance(DC_FilterLayout_t &layout, DC_Work_t &work,
00371                           DC_Placement_t &placement,
00372                           DC_FilterInstance_t *pinstance);
00373   int NewFilterInstance(DC_FilterLayout_t &layout, DC_Work_t &work,
00374                         DC_Placement_t &placement,
00375                         DC_FilterInstance_t *&pinstance);
00376   int GetFilterInstance(DC_FilterLayout_t &layout, DC_Work_t &work,
00377                         DC_Placement_t &placement,
00378                         DC_FilterInstance_t *&pinstance);
00379   int StopFilterInstance(DC_FilterInstance_t *&pinstance, bool fWait=true);
00380 
00381     
00382   // check status of a piece of work
00383   int ProbeWork(DC_WorkHandle_t wh, int *status);
00384     
00386   int WaitWork(DC_WorkHandle_t wh);
00387 
00388   //int WaitAllWork(void); // wait for all appended work to finish
00389   //int WaitAllWork(DC_FilterInstance_t &*pinstance);
00390 
00392   DC_WorkHandle_t WaitAnyWork(void);
00393 
00394   //DC_WorkHandle_t DC.WaitAnyWork(DC_FilterInstance_t &*pinstance);
00395 
00396   int ExitStatus(DC_WorkHandle_t wh);
00397 
00398   void FilterLock(void);
00399 
00400   void FilterUnlock(void);
00401 
00402 #if 0 // TODO: come back and re-implement this
00403   int ConsolePrintf(char *sbFormat, ...);
00404   int ConsoleOutput(MemoryBuf *pbuf, bool fLock=true);
00405   int ConsoleOutput(MemoryBuf &buf, bool fLock=true) {
00406     return ConsoleOutput(&buf, fLock);
00407   };
00408 #endif
00409 
00411   char *FindAppConfig(const char *sbName, const char *sbFilterName=NULL,
00412                       int wId=-1);
00413 
00415   long FindAppConfigInt(const char *sbName, const char *sbFilterName=NULL,
00416                         int wId=-1, bool fInterpretUnits=true);
00417 
00419   double FindAppConfigDbl(const char *sbName, const char *sbFilterName=NULL,
00420                           int wId=-1);
00421 };
00422 
00423 #endif /* H_DC_FILTERSERVICE */
00424 // ****************************************************************************

Generated on Fri Aug 9 15:46:13 2002 for DataCutter by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002