mariadb-columnstore-engine/utils/querytele/queryteleprotoimpl.cpp

/* 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. */

#include <queue>
#include <sstream>
#include <fstream>
using namespace std;

#define BOOST_DISABLE_ASSERTS
#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>

#include "thrift/transport/TSocket.h"
#include "thrift/transport/TBufferTransports.h"
namespace att = apache::thrift::transport;

#include "thrift/protocol/TBinaryProtocol.h"
namespace atp = apache::thrift::protocol;

#include "atomicops.h"

#include "queryteleserverparms.h"
#include "querytele_types.h"
#include "QueryTeleService.h"

#include "queryteleprotoimpl.h"

namespace
{
const size_t MaxQueueElems = 1000;

template <class T>
struct TsTeleQueue
{
    typedef std::queue<T> TeleQueue;

    TeleQueue queue;
    boost::mutex queueMtx;
};

TsTeleQueue<querytele::StepTele> stQueue;
TsTeleQueue<querytele::QueryTele> qtQueue;
TsTeleQueue<querytele::ImportTele> itQueue;

volatile bool isInited = false;
boost::mutex initMux;

boost::shared_ptr<att::TSocket> fSocket;
boost::shared_ptr<att::TBufferedTransport> fTransport;
boost::shared_ptr<atp::TBinaryProtocol> fProtocol;

querytele::StepTele gLastStep;

struct QStats
{
    int qtqueuedrops;
    int stqueuedrops;
    int stqueuedups;
    int itqueuedrops;
    QStats() :
        qtqueuedrops(0),
        stqueuedrops(0),
        stqueuedups(0),
        itqueuedrops(0) { ; }
};

QStats fQStats;

string get_trace_file()
{
    ostringstream oss;
    pid_t pid = getpid();
#ifdef _MSC_VER
    DWORD threadid = GetCurrentThreadId();
#else
    pthread_t threadid = pthread_self();
#endif
    oss << "/tmp/qt-consumer-" << pid << "-" << threadid;

    return oss.str();
}

void log_query(const querytele::QueryTele& qtdata)
{
    ofstream trace(get_trace_file().c_str(), ios::out | ios::app);
    trace << "Query,"
          <<  qtdata.query_uuid << ","
          << ","; // skip step uuid

    if (qtdata.msg_type == querytele::QTType::QT_SUMMARY)
        trace << "SUMMARY,";
    else if (qtdata.msg_type == querytele::QTType::QT_START)
        trace << "START,";
    else
        trace << "PROGRESS,";

    trace << ","; // sktp step type

    trace << qtdata.start_time << ",";
    trace << qtdata.end_time << ",";

    trace << qtdata.cache_io << ",";
    trace << qtdata.msg_rcv_cnt << ",";
    trace << qtdata.rows << ",";
    trace << qtdata.max_mem_pct << ",";

    trace << qtdata.query_type << ",";
    trace << qtdata.schema_name << ",";
    trace << qtdata.query << ",";
    trace << qtdata.system_name;
    trace << endl;
    trace.close();
}

const string st2str(enum querytele::StepType::type t)
{
    switch (t)
    {
        case querytele::StepType::T_HJS:
            return "HJS";

        case querytele::StepType::T_DSS:
            return "DSS";

        case querytele::StepType::T_CES:
            return "CES";

        case querytele::StepType::T_SQS:
            return "SQS";

        case querytele::StepType::T_TAS:
            return "TAS";

        case querytele::StepType::T_TNS:
            return "TNS";

        case querytele::StepType::T_BPS:
            return "BPS";

        case querytele::StepType::T_TCS:
            return "TCS";

        case querytele::StepType::T_HVS:
            return "HVS";

        case querytele::StepType::T_WFS:
            return "WFS";

        case querytele::StepType::T_SAS:
            return "SAS";

        case querytele::StepType::T_TUN:
            return "TUN";

        default:
            return "INV";
    }

    return "INV";
}

void log_step(const querytele::StepTele& stdata)
{
    ofstream trace(get_trace_file().c_str(), ios::out | ios::app);

    trace << "Step,"
          << stdata.query_uuid << ","
          << stdata.step_uuid << ",";

    if (stdata.msg_type == querytele::STType::ST_SUMMARY)
        trace << "SUMMARY,";
    else if (stdata.msg_type == querytele::STType::ST_START)
        trace << "START,";
    else
        trace << "PROGRESS,";

    trace << st2str(stdata.step_type) << ",";

    trace << stdata.start_time << ",";
    trace << stdata.end_time << ",";

    trace << stdata.cache_io << ",";
    trace << stdata.msg_rcv_cnt << ",";
    trace << stdata.rows << ",";

    if (stdata.total_units_of_work > 0)
        trace << stdata.units_of_work_completed * 100 / stdata.total_units_of_work << ",";
    else
        trace << "-1,";

    trace << ",,,"; // skip qtype, schemo, etc.
    trace << fQStats.stqueuedrops << "," << fQStats.stqueuedups << "," << stQueue.queue.size();
    trace << endl;
    trace.close();
}

void TeleConsumer()
{
    bool didSomeWork = false;
    boost::mutex::scoped_lock itlk(itQueue.queueMtx, boost::defer_lock);
    boost::mutex::scoped_lock qtlk(qtQueue.queueMtx, boost::defer_lock);
    boost::mutex::scoped_lock stlk(stQueue.queueMtx, boost::defer_lock);
    querytele::QueryTeleServiceClient client(fProtocol);

    try
    {
        for (;;)
        {
            didSomeWork = false;

            itlk.lock();

            // Empty the import queue first...
            while (!itQueue.queue.empty())
            {
                querytele::ImportTele itdata = itQueue.queue.front();
                itQueue.queue.pop();
                itlk.unlock();

                try
                {
                    fTransport->open();
                    client.postImport(itdata);
                    fTransport->close();
                }
                catch (...)
                {
                    try
                    {
                        fTransport->close();
                    }
                    catch (...)
                    {
                    }
                }

                didSomeWork = true;
                itlk.lock();
            }

            itlk.unlock();

            qtlk.lock();

            // Now empty the query queue...
            while (!qtQueue.queue.empty())
            {
                querytele::QueryTele qtdata = qtQueue.queue.front();
                qtQueue.queue.pop();
                qtlk.unlock();

                try
                {
                    fTransport->open();
#ifdef QUERY_TELE_DEBUG
                    log_query(qtdata);
#endif
                    client.postQuery(qtdata);
                    fTransport->close();
                }
                catch (...)
                {
                    try
                    {
                        fTransport->close();
                    }
                    catch (...)
                    {
                    }
                }

                didSomeWork = true;
                qtlk.lock();
            }

            qtlk.unlock();

            stlk.lock();

            // Finally empty the step queue...
            // @bug6088 - Added check for query queue and import queue in while statment below to
            //            keep the step logs from starving the query and import logs.
            while (!stQueue.queue.empty() && qtQueue.queue.empty() && itQueue.queue.empty())
            {
                querytele::StepTele stdata = stQueue.queue.front();
                stQueue.queue.pop();
                stlk.unlock();

                try
                {
                    fTransport->open();
#ifdef QUERY_TELE_DEBUG
                    log_step(stdata);
#endif
                    client.postStep(stdata);
                    fTransport->close();
                }
                catch (...)
                {
                    try
                    {
                        fTransport->close();
                    }
                    catch (...)
                    {
                    }
                }

                didSomeWork = true;
                stlk.lock();
            }

            stlk.unlock();

            if (!didSomeWork)
            {
                usleep(50000);
            }
        }
    }
    catch (...)
    {
        //we're probably shutting down, just let this thread die quietly...
    }
}

boost::thread* consThd;

}

namespace querytele
{

QueryTeleProtoImpl::QueryTeleProtoImpl(const QueryTeleServerParms& sp) :
    fServerParms(sp)
{
    if (fServerParms.host.empty() || fServerParms.port == 0) return;

    boost::mutex::scoped_lock lk(initMux);

    atomicops::atomicMb();

    if (isInited) return;

    fSocket.reset(new att::TSocket(fServerParms.host, fServerParms.port));
    fTransport.reset(new att::TBufferedTransport(fSocket));
    fProtocol.reset(new atp::TBinaryProtocol(fTransport));

    consThd = new boost::thread(&TeleConsumer);

    atomicops::atomicMb();
    isInited = true;
}

int QueryTeleProtoImpl::enqStepTele(const StepTele& stdata)
{
    try
    {
        boost::mutex::scoped_lock lk(stQueue.queueMtx);

        // @bug6088 - Added conditions below to always log progress SUMMARY and START messages to avoid completed queries showing up with progress 0
        //            and no steps.
        if (stQueue.queue.size() >= MaxQueueElems && stdata.msg_type != querytele::STType::ST_SUMMARY && stdata.msg_type != querytele::STType::ST_START)
        {
            fQStats.stqueuedrops++;
            return -1;
        }

        if ( stdata.step_uuid != gLastStep.step_uuid ||
                stdata.msg_type != gLastStep.msg_type ||
                stdata.step_type != gLastStep.step_type ||
                stdata.total_units_of_work != gLastStep.total_units_of_work ||
                stdata.units_of_work_completed != gLastStep.units_of_work_completed )
        {
            stQueue.queue.push(stdata);
            gLastStep = stdata;
        }
        else
        {
            fQStats.stqueuedups++;
        }
    }
    catch (...)
    {
        return -2;
    }

    return 0;
}

int QueryTeleProtoImpl::enqQueryTele(const QueryTele& qtdata)
{
    try
    {
        boost::mutex::scoped_lock lk(qtQueue.queueMtx);

        if (qtQueue.queue.size() >= MaxQueueElems)
        {
            fQStats.qtqueuedrops++;
            return -1;
        }

        qtQueue.queue.push(qtdata);
    }
    catch (...)
    {
        return -2;
    }

    return 0;
}

int QueryTeleProtoImpl::enqImportTele(const ImportTele& itdata)
{
    try
    {
        boost::mutex::scoped_lock lk(itQueue.queueMtx);

        if (itQueue.queue.size() >= MaxQueueElems)
        {
            fQStats.itqueuedrops++;
            return -1;
        }

        itQueue.queue.push(itdata);
    }
    catch (...)
    {
        return -2;
    }

    return 0;
}

int QueryTeleProtoImpl::waitForQueues()
{
    try
    {
        boost::mutex::scoped_lock lk(itQueue.queueMtx);

        while (!itQueue.queue.empty())
        {
            lk.unlock();
            usleep(100000);
            lk.lock();
        }
    }
    catch (...)
    {
        return -1;
    }

    return 0;
}

} //namespace querytele