transactd 1.2.0 → 2.0.0

data/source/bzs/test/transactdBench/query_bench.cpp

@@ -0,0 +1,156 @@
+/*=================================================================
+   Copyright (C) 2014 BizStation Corp All rights reserved.
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.
+=================================================================*/
+#include <bzs/db/protocol/tdap/client/activeTable.h>
+#include <bzs/rtl/benchmark.h>
+#include <bzs/example/queryData.h>
+#include <iostream>
+#include <locale.h>
+
+using namespace bzs::db::protocol::tdap::client;
+using namespace bzs::db::protocol::tdap;
+
+void showConsole(recordset& rowset)
+{
+    const fielddefs& fields = *rowset.fieldDefs();
+    for (int j = 0; j < (int)fields.size(); ++j)
+        std::tcout << fields[j].name() << _T("\t");
+    std::tcout << _T("\n");
+
+    for (int i = 0; i < (int)rowset.size(); ++i)
+    {
+        row& m = rowset[i];
+        for (int j = 0; j < (int)m.size(); ++j)
+        {
+            std::tcout << m[(short)j].c_str() << _T("\t");
+            if (j == (int)m.size() - 1)
+                std::tcout << _T("\n");
+        }
+    }
+}
+
+bool btest(recordset* rsp, activeTable* atup, activeTable* atgp,
+           activeTable* atep, int kind, int n)
+{
+#ifdef LINUX
+    const char* fd_name = "名前";
+#else
+#ifdef _UNICODE
+    const wchar_t* fd_name = L"名前";
+#else
+    char fd_name[30];
+    WideCharToMultiByte(CP_UTF8, 0, L"名前", -1, fd_name, 30, NULL, NULL);
+#endif
+#endif
+
+    activeTable& atu = *atup;
+    activeTable& atg = *atgp;
+    activeTable& ate = *atep;
+    recordset& rs = *rsp;
+    query q;
+
+    for (int i = 0; i < n; ++i)
+    {
+        rs.clear();
+        if (kind & 1)
+        {
+            q.reset();
+            atu.alias(fd_name, _T("name"));
+
+            q.select(_T("id"), _T("name"), _T("group"))
+                .where(_T("id"), _T("<="), i + 15000);
+            atu.index(0).keyValue(i + 1).read(rs, q);
+
+            // Join extention::comment
+            if (kind & 2)
+            {
+                q.reset();
+                ate.index(0).join(rs, q.select(_T("comment")).optimize(
+                                          queryBase::joinHasOneOrHasMany),
+                                  _T("id"));
+            }
+            if (kind & 4)
+            {
+                // Join group::name
+                q.reset();
+                atg.alias(_T("name"), _T("group_name"));
+                atg.index(0).join(rs, q.select(_T("group_name")), _T("group"));
+            }
+        }
+        if (kind & 8)
+            std::tcout << "." << std::flush;
+    }
+    if (kind & 8)
+        std::tcout << std::endl;
+    return true;
+}
+
+#pragma warning(disable : 4101)
+#pragma argsused
+int _tmain(int argc, _TCHAR* argv[])
+{
+#ifdef _UNICODE
+    std::locale::global(std::locale(""));
+#endif
+    database_ptr db = createDatabaseObject();
+    try
+    {
+        const _TCHAR* host = _T("localhost");
+        int kind = 15;
+        int n = 100;
+        bool makeDatabase = true;
+
+        if (argc >= 5)
+            n = _ttol(argv[4]);
+        if (argc >= 4)
+            kind = _ttol(argv[3]);
+        if (argc >= 3)
+            host = argv[2];
+        if (argc >= 2)
+            makeDatabase = (_ttol(argv[1]) != 0);
+#ifndef USE_PSQL_DATABASE
+        connectParams param(_T("tdap"), host, _T("querytest"), _T("test"));
+#else
+        connectParams param(_T("btrv"), host, _T("querytest"), _T("test"));
+#endif
+        param.setMode(TD_OPEN_NORMAL);
+        if (prebuiltData(db, param, makeDatabase))
+        {
+            std::tcout << "The query data build error." << std::endl;
+            return 1;
+        }
+        activeTable atu(db, _T("user"));
+        activeTable atg(db, _T("groups"));
+        activeTable ate(db, _T("extention"));
+
+        recordset rs;
+
+        bzs::rtl::benchmark bm;
+        bm.report(boost::bind(btest, &rs, &atu, &atg, &ate, kind, n),
+                  "exec time ");
+
+        return 0;
+    }
+
+    catch (bzs::rtl::exception& e)
+    {
+        std::tcout << *bzs::rtl::getMsg(e) << std::endl;
+    }
+    return 1;
+}
+#pragma warning(default : 4101)

data/source/bzs/test/transactdBench/scaling_bench.cpp

@@ -0,0 +1,265 @@
+/*=================================================================
+   Copyright (C) 2014 BizStation Corp All rights reserved.
+
+   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; either version 2
+   of the License, or (at your option) any later version.
+
+   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., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.
+=================================================================*/
+#pragma hdrstop
+#include "workerTransactdImple.h"
+#include "workerMySQLImple.h"
+
+using namespace bzs::test::worker;
+using namespace boost;
+
+typedef std::vector<boost::shared_ptr<workerBase> > workers;
+
+struct transactionSec
+{
+    transactionSec() : value(0) {}
+    int workes;
+    __int64 value;
+};
+
+struct commandLineParam
+{
+    int funcNumber;
+    int maxWorkerNum;
+    int workerNumStep;
+    int loopCount;
+    int avg_count;
+    int stressMode;
+    commandLineParam(_TCHAR* argv[])
+    {
+        funcNumber = _ttol(argv[2]);
+        maxWorkerNum = _ttol(argv[3]);
+        workerNumStep = maxWorkerNum / 20;
+        if (workerNumStep == 0)
+            workerNumStep = 1;
+        loopCount = _ttol(argv[4]);
+        avg_count = _ttol(argv[5]);
+        stressMode = (loopCount == -1) ? true : false;
+        if (stressMode)
+            loopCount = 1;
+    }
+};
+
+void showResult(const std::vector<transactionSec>& results, int total,
+                int totalTransactionTime, int totalTransactions,
+                bool stressMode)
+{
+    std::tcout << _T("----------------------------------") << std::endl;
+    std::tcout << _T("Clients \tTransactions/sec") << std::endl;
+    std::tcout << _T("----------------------------------") << std::endl;
+
+    for (int i = 0; i < (int)results.size(); ++i)
+        std::tcout << results[i].workes << _T("\t") << results[i].value
+                   << std::endl;
+    if (!stressMode)
+    {
+        std::tcout << _T("----------------------------------") << std::endl;
+        std::tcout << _T("total transaction time   (sec) ")
+                   << totalTransactionTime / 1000000.0f << std::endl;
+        std::tcout << _T("avarage transaction time (sec) ")
+                   << totalTransactionTime / 1000000.0f / totalTransactions
+                   << std::endl;
+        std::tcout << _T("total testing time       (sec) ")
+                   << total / 1000000.0f << std::endl;
+    }
+    std::tcout << _T("----------------------------------") << std::endl;
+}
+
+bool tableFixer(const connectParams& param)
+{
+
+    database_ptr db = createDatabaseObject();
+    openDatabase(db, param);
+
+    dbdef* def = db->dbDef();
+    short index = def->tableNumByName(_T("cache"));
+    if (index == -1 && !createCacheTable(def))
+        return false;
+    dropTable(db, _T("cache"));
+    openTable(db, _T("cache"));
+    return true;
+}
+
+void makeMysqlParam(bzs::test::worker::mysql::connectParam& param,
+                    const _TCHAR* host)
+{
+#ifdef _UNICODE
+    char hostname[256];
+    WideCharToMultiByte(CP_ACP, 0, host, -1, hostname, 256, NULL, NULL);
+#else
+    const char* hostname = host;
+#endif
+    param.hostname = hostname;
+    param.username = "root";
+    param.passwd = "";
+    param.database = "querytest";
+    param.port = 0;
+}
+
+#define BENCH_TIMER_SECONDS 1.5f
+double executeWorkers(const commandLineParam& cmd, const connectParams param,
+                      const bzs::test::worker::mysql::connectParam& paramMysql,
+                      int wn)
+{
+    double t = 0;
+    for (int k = 0; k < cmd.avg_count; ++k)
+    {
+        g_bench_signal = cmd.stressMode ? BENCH_SIGNAL_GO : BENCH_SIGNAL_BLUE;
+        workers workers;
+        thread_group threads;
+        boost::barrier sync(wn + 1);
+        for (int i = 0; i < wn; ++i)
+        {
+            int id = i + (wn * 10000);
+
+            boost::shared_ptr<workerBase> w;
+            if (cmd.funcNumber < 10)
+                w.reset(new transactd::worker(id, cmd.loopCount, cmd.funcNumber,
+                                              param, sync));
+            else
+                w.reset(new bzs::test::worker::mysql::worker(
+                    id, cmd.loopCount, cmd.funcNumber, paramMysql, sync));
+            workers.push_back(w);
+            threads.create_thread(bind(&workerBase::execute, w.get()));
+        }
+        printf("*");
+        fflush(stdout);
+        Sleep(200 * MCRTOMM);
+        sync.wait(); // start all workers
+        if (cmd.stressMode)
+        {
+            Sleep(200 * MCRTOMM);
+            g_bench_signal = BENCH_SIGNAL_GREEN;
+            Sleep((unsigned int)(BENCH_TIMER_SECONDS * 1000 * MCRTOMM));
+            g_bench_signal = BENCH_SIGNAL_BREAK;
+        }
+        threads.join_all();
+        for (int i = 0; i < wn; ++i)
+            t += workers[i]->total();
+    }
+    return t;
+}
+
+int execute(const commandLineParam& cmd, const connectParams param,
+            const bzs::test::worker::mysql::connectParam& paramMysql,
+            std::vector<transactionSec>& results, double& totalTransactionTime)
+{
+    int totalTransactions = 0;
+    for (int wn = cmd.workerNumStep; wn <= cmd.maxWorkerNum;
+         wn += cmd.workerNumStep)
+    {
+        double t = executeWorkers(cmd, param, paramMysql, wn);
+        transactionSec ts;
+        if (cmd.stressMode)
+        {
+            if (t)
+                ts.value = (__int64)(t / BENCH_TIMER_SECONDS);
+        }
+        else
+        {
+            totalTransactionTime += t;
+            totalTransactions += wn * cmd.loopCount * cmd.avg_count;
+            if (t)
+                ts.value = (__int64)((double)1000000.0f * wn * wn *
+                                     cmd.avg_count * cmd.loopCount / t);
+        }
+        ts.workes = wn;
+        results.push_back(ts);
+    }
+    return totalTransactions;
+}
+
+void showUsage()
+{
+    printf("\nusage: bench_scale [host] [function_number] [max_worker_num]"
+           " [trnsactions] [avg_count]\n"
+           "\n"
+           "|----- [function_number] description      -----|\n"
+           "| 0: Read a record by unique id.               |\n"
+           "| 1: Insert a record by autoincrement.         |\n"
+           "| 2: Read 50 user records and join group name. |\n"
+           "| +10 Test MySQL (10 11 12)                    |\n"
+           "|----------------------------------------------|\n"
+           "\n"
+           "|----- [trnsactions] description          -----|\n"
+           "|  1 - n : N times roop a function             |\n"
+           "| -1     : Execute Infinite loop and the number|\n"
+           "|          of processings within regulation    |\n"
+           "|          time is counted.                    |\n"
+           "|----------------------------------------------|\n"
+           "\n"
+           "|----- [avg_count] description            -----|\n"
+           "|  1 - n : Count N times and results return    |\n"
+           "|          those avarage.                      |\n"
+           "|----------------------------------------------|\n"
+
+           "exsample : bench_scale localhost 0 100 1 5     \n");
+}
+
+#pragma argsused
+int _tmain(int argc, _TCHAR* argv[])
+{
+    try
+    {
+        if (argc < 6)
+        {
+            showUsage();
+            return 0;
+        }
+        bzs::test::worker::mysql::mysqlInit mysql;
+
+        if (!mysql_thread_safe())
+        {
+            std::tcout << _T("MySQL client is not thread safe.") << std::endl;
+            return 1;
+        }
+
+        connectParams param(_T("tdap"), argv[1], _T("querytest"), _T("test"));
+        param.setMode(0);
+
+        bzs::test::worker::mysql::connectParam paramMysql(
+            argv[1], _T("querytest"), _T("root"));
+
+        commandLineParam cmd(argv);
+
+        if (tableFixer(param))
+        {
+            std::vector<transactionSec> results;
+            results.reserve(cmd.maxWorkerNum);
+            pooledDbManager::setMaxConnections(cmd.maxWorkerNum);
+
+            double totalTransactionTime = 0;
+            bzs::rtl::benchmarkMt bm;
+            bm.start();
+            int totalTransactions =
+                execute(cmd, param, paramMysql, results, totalTransactionTime);
+            printf("\n");
+            showResult(results, bm.end(), (int)totalTransactionTime,
+                       totalTransactions, cmd.stressMode);
+            return 0;
+        }
+        return 1;
+    }
+
+    catch (bzs::rtl::exception& e)
+    {
+        std::_tstring s = *bzs::rtl::getMsg(e);
+        std::tcout << _T("[ERROR] ") << s << std::endl;
+    }
+    return 1;
+}