// **********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
// **********************************************************************
#ifndef COMPILERTRACKING_H
#define COMPILERTRACKING_H

#include "NAString.h"
#include "CmpCommon.h"
#include "SchemaDB.h"
#include "opt.h"
#include "NATable.h"
#include <time.h>
#include <fstream>
#include "QCache.h"
#include "CmpProcess.h"

//
// the private user table where the data can be loggeed
#define COMPILER_TRACKING_TABLE_NAME_PRIVATE "STATE_TRACKING_COMPILERS_TABLE_PRIVATE"
/************************************************************************
class CompilerTrackingInfo

Singleton class to collect information about this compiler 
and to be logged into a file or a private user table on some interval 
(every N minutes)

************************************************************************/
class CompilerTrackingInfo
{
public:

  // get the singleton instance
  //static CompilerTrackingInfo * getInstance();
  CompilerTrackingInfo(CollHeap *outHeap = CmpCommon::contextHeap());
  //
  // initialize the singleton
  //static void initGlobalInstance();
  //
  // log all of the data members of this object
  void logCompilerStatusOnInterval(Int32 intervalLengthMins);
  // 
  // the cpu time for the longest compilation is updated
  // if the parameter is longer than the current longest
  void updateLongestCompile( Lng32 c );
  //
  // the largest statement heap size so far 
  // update this right before deleting the CmpStatement
  void updateStmtIntervalWaterMark();
  //
  // the largest system heap size so far
  // update this right before cleanup (in CmpMain.cpp)
  void updateSystemHeapWtrMark();
  //
  // the largest qcache heap size so far
  // update this right before deleting the qcache
  void updateQCacheIntervalWaterMark();
  //
  // the number of successfully compiled queries
  void incrementQueriesCompiled( NABoolean success );  
  //
  // compiled successfully but with warnings 2053 or 2078
  void incrementCaughtExceptions()
    { caughtExceptionCount_++; }
  //
  // when the QueryCache is being deleted, clear the
  // markers we used to determine difference during 
  // the interval.
  void clearQCacheCounters();
  //
  // maximum # of characters for compiler info
  enum { MAX_COMPILER_INFO_LEN = 4096 };

  // start the new interval (at the current time, clock())
  // if the previous interval tracking was disabled
  void resetIntervalIfNeeded();
  
// methods used internally within the class...
protected:
  //
  // check to see if an interval has expired
  NABoolean intervalExpired(Int32 intervalLengthMins);
  //
  // start the new interval (at the current time, clock())
  void resetInterval();

  // the duration of the interval in minutes
  Int32 currentIntervalDuration(Int64 endTime);
  //
  // the cpu time for the interval
  Lng32 cpuPathLength();
  //
  // getters
  inline Int64 beginIntervalTime() 
    { return beginIntervalTime_ ; }

  // return the beginning of the interval in unix epoch
  inline Int64 beginIntervalTimeUEpoch()
    { return beginIntervalTimeUEpoch_ ; }

  inline Int64 endIntervalTime()
    { return endIntervalTime_; }

  inline Lng32 beginIntervalClock()
    { return beginIntervalClock_; }
  //
  // the compiler age in minutes
  inline Lng32 compilerAge()
  {
    Int64 seconds = (processInfo_->getProcessDuration() / 1000000);
    Int64 minutes = (seconds / 60);
    return int64ToInt32(minutes); 
  }
  //
  // statement heap
  inline size_t stmtHeapCurrentSize()
    { return CmpCommon::statementHeap()->getAllocSize(); }

  inline size_t stmtHeapIntervalWaterMark();  
  //
  // context heap
  inline size_t cxtHeapCurrentSize()
    { return CmpCommon::contextHeap()->getAllocSize(); }

  inline size_t cxtHeapIntervalWaterMark()
    { return CmpCommon::contextHeap()->getIntervalWaterMark(); }
  //
  // metadata cache
  inline ULng32 metaDataCacheCurrentSize()
    { return ActiveSchemaDB()->getNATableDB()->currentCacheSize(); }

  inline ULng32 metaDataCacheIntervalWaterMark()
    { return ActiveSchemaDB()->getNATableDB()->intervalWaterMark();}

  inline ULng32 metaDataCacheHits();
  inline ULng32 metaDataCacheLookups();
  void resetMetadataCacheCounters();
  //
  // query cache
  inline ULng32 qCacheCurrentSize();
  inline ULng32 qCacheIntervalWaterMark();  
  inline ULng32 qCacheHits();
  inline ULng32 qCacheLookups();
  inline ULng32 qCacheRecompiles();
  void resetQueryCacheCounters();
  // 
  // histogram cache
  inline ULng32 hCacheCurrentSize()
  {   
      CMPASSERT(NULL!=CURRCONTEXT_HISTCACHE); 
      return CURRCONTEXT_HISTCACHE->getHeap()->getAllocSize(); 
  }

  inline ULng32 hCacheIntervalWaterMark()
  { 
      CMPASSERT(NULL!=CURRCONTEXT_HISTCACHE); 
      return CURRCONTEXT_HISTCACHE->getHeap()->getIntervalWaterMark(); 
  }

  inline ULng32 hCacheHits();
  inline ULng32 hCacheLookups();
  void resetHistogramCacheCounters();

  inline Lng32 systemHeapIntervalWaterMark()
    { return systemHeapWaterMark_; }

  inline Lng32 longestCompile()
    { return longestCompileClock_; } 

  inline ULng32 successfulQueryCount() 
    { return successfulQueryCount_; }

  inline ULng32 failedQueryCount()
    { return failedQueryCount_; }

  inline ULng32 caughtExceptionCount()
    { return caughtExceptionCount_; }

  inline ULng32 sessionCount();

  inline const char *compilerInfo()
    { return compilerInfo_; }  
  //
  // for printing to file
  enum { CACHE_HEAP_HEADER_LEN = 18, 
         CACHE_HEAP_VALUE_LEN = 16 };
  //
  // just do the printing
  void printToFile();

  // log to a user table
  void logIntervalInPrivateTable();

  // log to a log4cxx appender
  void logIntervalInLog4Cxx();

private:
  ~CompilerTrackingInfo();

  // The process info contains information such as cpu num, pin, etc
  CmpProcess *processInfo_;
  //
  // timestamp for when this interval began
  Int64 beginIntervalTime_;
  //
  // timestamp for when this interval began in unix epoch
  Int64 beginIntervalTimeUEpoch_;
  //
  // timestamp for when this interval ended
  Int64 endIntervalTime_;
  //
  //  cpu path length for this interval
  Lng32 beginIntervalClock_;
  //
  // the most memory used in a CmpStatement so far
  size_t largestStmtIntervalWaterMark_;
  //
  // the most memory used by system heap so far
  Lng32 systemHeapWaterMark_;
  //
  // cpu path for the longest compile so far
  Lng32 longestCompileClock_;
  //
  // metadata cache counters
  ULng32 mdCacheHits_;
  ULng32 mdCacheLookups_;
  //
  // query plan cache stats
  QCacheStats currentQCacheStats_;
  ULng32 largestQCacheIntervalWaterMark_;
  ULng32 qCacheHits_;
  ULng32 qCacheLookups_;
  ULng32 qCacheRecompiles_;
  //
  // histogram cache counters
  ULng32 hCacheHits_;
  ULng32 hCacheLookups_;
  //
  // the number of queries compiled during this interval
  ULng32 successfulQueryCount_;
  ULng32 failedQueryCount_;
  //
  // the number of exceptions caught (2053 and 2078)
  ULng32 caughtExceptionCount_;
  //
  // the number of sessions
  ULng32 sessionCount_;
  //
  // the length of the last interval (set by CQD)
  ULng32 prevInterval_;
  //
  // additional compiler information
  char compilerInfo_[MAX_COMPILER_INFO_LEN];
  //
  // the heap created on
  CollHeap *heap_;
};
#endif