/* Copyright (C) 2014 InfiniDB, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/******************************************************************************
 * $Id: MonitorProcMem.cpp 2035 2013-01-21 14:12:19Z rdempsey $
 *
 *****************************************************************************/

#ifdef _MSC_VER
#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
#include <process.h>
#include <psapi.h>
#endif
#include <sys/types.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <stdint.h>
using namespace std;

#include "messageids.h"
#include "messageobj.h"
#include "loggingid.h"
#include "logger.h"
using namespace logging;

#include "MonitorProcMem.h"

namespace utils
{

uint64_t MonitorProcMem::fMemTotal = 1;
uint64_t MonitorProcMem::fMemFree = 0;
int      MonitorProcMem::fMemPctCheck = 0;

//------------------------------------------------------------------------------
// Thread entry point function, that drives a thread to periodically (every
// 1 seconds by default) monitor the memory usage for the process we are
// running in. Call getAvailablePct() or memUsedPct() to access the current value.
//------------------------------------------------------------------------------
void MonitorProcMem::operator()() const
{
    while (1)
    {
        if (fMaxPct > 0)
        {
            size_t pct = rss() * 100 / fMemTotal;

            if (pct > fMaxPct)
            {
                cerr << "PrimProc: Too much memory allocated!" << endl;

                LoggingID logid(fSubsystemID);
                logging::Message msg(logging::M0045);
                logging::Message::Args args;
                msg.format(args);
                logging::Logger logger(logid.fSubsysID);
                logger.logMessage(LOG_TYPE_CRITICAL, msg, logid);
                exit(1);
            }
        }

        fMemFree = cg.getFreeMemory();
        //calculateFreeMem();
        pause_();
    }
}

//------------------------------------------------------------------------------
// Returns the maximum memory available on the current host this process is
// running on.
//------------------------------------------------------------------------------
size_t MonitorProcMem::memTotal() const
{
    return cg.getTotalMemory();
}

//------------------------------------------------------------------------------
// Returns the RSS memory usage for the current process by reading the pid's
// statm file.
//------------------------------------------------------------------------------
size_t MonitorProcMem::rss() const
{
    uint64_t rss;

#if defined(_MSC_VER)
    HANDLE hProcess;
    PROCESS_MEMORY_COUNTERS pmc;
    hProcess = OpenProcess(  PROCESS_QUERY_INFORMATION |
                             PROCESS_VM_READ,
                             FALSE, fPid );

    if (NULL == hProcess)
        return 0;

    if ( GetProcessMemoryInfo( hProcess, &pmc, sizeof(pmc)) )
        rss = pmc.WorkingSetSize;
    else
        rss = 0;

    CloseHandle( hProcess );
#elif defined(__FreeBSD__)
    ostringstream cmd;
    cmd << "ps -a -o rss -p " << getpid() << " | tail +2";
    FILE* cmdPipe;
    char input[80];
    cmdPipe = popen(cmd.str().c_str(), "r");
    input[0] = '\0';
    fgets(input, 80, cmdPipe);
    input[79] = '\0';
    pclose(cmdPipe);
    rss = atoi(input) * 1024LL;
#else
    ostringstream pstat;
    pstat << "/proc/" << fPid << "/statm";
    ifstream in(pstat.str().c_str());
    size_t x;

    in >> x;
    in >> rss;

    //rss is now in pages, convert to bytes
    rss *= fPageSize;
#endif

    return static_cast<size_t>(rss);
}

//------------------------------------------------------------------------------
// Stays in "sleep" state till fSleepSec seconds have elapsed.
//------------------------------------------------------------------------------
void MonitorProcMem::pause_( ) const
{
    struct timespec req;
    struct timespec rem;

    req.tv_sec  = fSleepSec;
    req.tv_nsec = 0;

    rem.tv_sec  = 0;
    rem.tv_nsec = 0;

    while (1)
    {
#ifdef _MSC_VER
        Sleep(req.tv_sec * 1000);
#else

        if (nanosleep(&req, &rem) != 0)
        {
            if (rem.tv_sec > 0 || rem.tv_nsec > 0)
            {
                req = rem;
                continue;
            }
        }

#endif
        break;
    }
}

//------------------------------------------------------------------------------
// Returns the system used memory %
//------------------------------------------------------------------------------
unsigned MonitorProcMem::memUsedPct()
{
    return ((100 * (fMemTotal - fMemFree)) / fMemTotal);
}

//------------------------------------------------------------------------------
// Returns if used memory (including new request) < configured memory check
//------------------------------------------------------------------------------
bool MonitorProcMem::isMemAvailable(size_t memRequest)
{
    int memAvailPct = ((100 * (fMemFree - memRequest)) / fMemTotal);
    return (memAvailPct < fMemPctCheck);
}

} // end of namespace