Moved buffertest to store/test and turned it into a reproducible benchmark.

9 files changed, 161 insertions, 103 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f16dc6a..0313b65 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -47,7 +47,7 @@ add_subdirectory(client)
 # the resource
 add_subdirectory(resource)
 
-# the buffertest
-add_subdirectory(buffertest)
+# the store
+add_subdirectory(store)
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/buffertest/CMakeLists.txt b/buffertest/CMakeLists.txt
deleted file mode 100644
index fd100d0..0000000
--- a/buffertest/CMakeLists.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-project(toynadi_buffertest)
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
-
-set(store_path "../store/")
-
-set(toynadinbuffertest_SRCS
-    ${store_path}/database.cpp
-    main.cpp
-)
-
-set(SCHEMAS calendar.fbs)
-set(SCHEMA_SOURCEFILES calendar_generated.h)
-
-add_custom_command(OUTPUT ${SCHEMA_SOURCEFILES}
-    COMMAND flatc -c ${CMAKE_CURRENT_SOURCE_DIR}/calendar.fbs
-    COMMENT "Generating buffers"
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    DEPENDS ${SCHEMAS}
-    VERBATIM
-)
-
-SET_SOURCE_FILES_PROPERTIES(${SCHEMA_SOURCEFILES} PROPERTIES GENERATED 1)
-ADD_CUSTOM_TARGET(generate_buffers ALL DEPENDS ${SCHEMA_SOURCEFILES})
-
-add_executable(${PROJECT_NAME} ${toynadinbuffertest_SRCS})
-qt5_use_modules(${PROJECT_NAME} Core)
-target_link_libraries(${PROJECT_NAME} lmdb)
-install(TARGETS ${PROJECT_NAME} DESTINATION bin)
-
diff --git a/buffertest/main.cpp b/buffertest/main.cpp
deleted file mode 100644
index 437e5b3..0000000
--- a/buffertest/main.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "calendar_generated.h"
-#include <iostream>
-#include <fstream>
-#include <QDir>
-#include <QString>
-#include <QTime>
-#include <qdebug.h>
-
-#include "store/database.h"
-
-using namespace Calendar;
-using namespace flatbuffers;
-
-std::string createEvent(bool createAttachment = false)
-{
-    FlatBufferBuilder fbb;
-    {
-        auto summary = fbb.CreateString("summary");
-
-        // const int attachmentSize = 1024 * 1024; // 1MB
-        const int attachmentSize = 1024*2; // 1KB
-        int8_t rawData[attachmentSize];
-        auto data = fbb.CreateVector(rawData, attachmentSize);
-
-        Calendar::EventBuilder eventBuilder(fbb);
-        eventBuilder.add_summary(summary);
-        eventBuilder.add_attachment(data);
-        auto eventLocation = eventBuilder.Finish();
-        FinishEventBuffer(fbb, eventLocation);
-    }
-    return std::string(reinterpret_cast<const char *>(fbb.GetBufferPointer()), fbb.GetSize());
-}
-
-void readEvent(const std::string &data)
-{
-    auto readEvent = GetEvent(data.c_str());
-    std::cout << readEvent->summary()->c_str() << std::endl;
-}
-
-int main(int argc, char **argv)
-{
-    Database db;
-    const int count = 50000;
-    QTime time;
-    time.start();
-    // std::ofstream myfile;
-    // myfile.open ("buffer.fb");
-    //
-    auto transaction = db.startTransaction();
-    for (int i = 0; i < count; i++) {
-        const auto key = QString("key%1").arg(i);
-        auto event = createEvent(true);
-        db.write(key.toStdString(), event, transaction);
-
-        // myfile << createEvent();
-    }
-    db.endTransaction(transaction);
-    // myfile.close();
-    qDebug() << "Writing took: " << time.elapsed();
-
-    time.start();
-    for (int i = 0; i < count; i++) {
-        const auto key = QString("key%1").arg(i);
-        db.read(key.toStdString());
-    }
-    qDebug() << "Reading took: " << time.elapsed();
-}
diff --git a/store/CMakeLists.txt b/store/CMakeLists.txt
new file mode 100644
index 0000000..552439e
--- /dev/null
+++ b/store/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(test)
diff --git a/store/database.cpp b/store/database.cpp
index d6fe7c0..c16a077 100644
--- a/store/database.cpp
+++ b/store/database.cpp
@@ -6,16 +6,16 @@
 #include <QTime>
 #include <qdebug.h>
 
-Database::Database()
+Database::Database(const QString &path)
 {
     int rc;
 
     QDir dir;
-    dir.mkdir("./testdb");
+    dir.mkdir(path);
 
     //create file
     rc = mdb_env_create(&env);
-    rc = mdb_env_open(env, "./testdb", 0, 0664);
+    rc = mdb_env_open(env, path.toStdString().data(), 0, 0664);
     const int dbSize = 10485760*100; //10MB * 100
     mdb_env_set_mapsize(env, dbSize);
 
diff --git a/store/database.h b/store/database.h
index b42b9f7..1a124be 100644
--- a/store/database.h
+++ b/store/database.h
@@ -1,9 +1,10 @@
 #include <lmdb.h>
 #include <string>
+#include <QString>
 
 class Database {
 public:
-    Database();
+    Database(const QString &path);
     ~Database();
     MDB_txn *startTransaction();
     void endTransaction(MDB_txn *transaction);
diff --git a/store/test/CMakeLists.txt b/store/test/CMakeLists.txt
new file mode 100644
index 0000000..4743cfb
--- /dev/null
+++ b/store/test/CMakeLists.txt
@@ -0,0 +1,21 @@
+set(CMAKE_AUTOMOC ON)
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+set(store_path "../")
+set(store_SRCS
+    ${store_path}/database.cpp
+)
+
+generate_flatbuffers(calendar)
+
+macro(manual_tests)
+    foreach(_testname ${ARGN})
+        add_executable(${_testname} ${_testname}.cpp ${store_SRCS})
+        qt5_use_modules(${_testname} Core Test)
+        target_link_libraries(${_testname} lmdb)
+    endforeach(_testname)
+endmacro(auto_tests)
+
+manual_tests (
+    storagebenchmark
+)
diff --git a/buffertest/calendar.fbs b/store/test/calendar.fbs
index 203ee43..203ee43 100644
--- a/buffertest/calendar.fbs
+++ b/store/test/calendar.fbs
diff --git a/store/test/storagebenchmark.cpp b/store/test/storagebenchmark.cpp
new file mode 100644
index 0000000..939ae0b
--- /dev/null
+++ b/store/test/storagebenchmark.cpp
@@ -0,0 +1,132 @@
+#include <QtTest>
+
+#include "calendar_generated.h"
+#include <iostream>
+#include <fstream>
+#include <QDir>
+#include <QString>
+#include <QTime>
+#include <qdebug.h>
+
+#include "store/database.h"
+
+using namespace Calendar;
+using namespace flatbuffers;
+
+static std::string createEvent()
+{
+    FlatBufferBuilder fbb;
+    {
+        auto summary = fbb.CreateString("summary");
+
+        const int attachmentSize = 1024*2; // 2KB
+        int8_t rawData[attachmentSize];
+        auto data = fbb.CreateVector(rawData, attachmentSize);
+
+        Calendar::EventBuilder eventBuilder(fbb);
+        eventBuilder.add_summary(summary);
+        eventBuilder.add_attachment(data);
+        auto eventLocation = eventBuilder.Finish();
+        FinishEventBuffer(fbb, eventLocation);
+    }
+    return std::string(reinterpret_cast<const char *>(fbb.GetBufferPointer()), fbb.GetSize());
+}
+
+static void readEvent(const std::string &data)
+{
+    auto readEvent = GetEvent(data.c_str());
+    std::cout << readEvent->summary()->c_str() << std::endl;
+}
+
+class StorageBenchmark : public QObject
+{
+    Q_OBJECT
+private:
+    //This should point to a directory on disk and not a ramdisk (since we're measuring performance)
+    QString testDataPath;
+    QString dbPath;
+    QString filePath;
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+        testDataPath = "./";
+        dbPath = testDataPath + "testdb";
+        filePath = testDataPath + "buffer.fb";
+
+        QDir dir(testDataPath);
+        dir.remove("testdb/data.mdb");
+        dir.remove("testdb/lock.mdb");
+        dir.remove(filePath);
+    }
+
+    void testWriteRead_data()
+    {
+        QTest::addColumn<bool>("useDb");
+        QTest::addColumn<int>("count");
+
+        const int count = 50000;
+        QTest::newRow("db, 50k") << true << count;
+        QTest::newRow("file, 50k") << false << count;
+    }
+
+    void testWriteRead()
+    {
+        QFETCH(bool, useDb);
+        QFETCH(int, count);
+
+        Database db(dbPath);
+
+        std::ofstream myfile;
+        myfile.open(filePath.toStdString());
+
+        QTime time;
+        time.start();
+        {
+            auto transaction = db.startTransaction();
+            for (int i = 0; i < count; i++) {
+                const auto key = QString("key%1").arg(i);
+                auto event = createEvent();
+                if (useDb) {
+                    db.write(key.toStdString(), event, transaction);
+                } else {
+                    myfile << event;
+                }
+            }
+            if (useDb) {
+                db.endTransaction(transaction);
+            } else {
+                myfile.close();
+            }
+        }
+        const int writeDuration = time.elapsed();
+        qDebug() << "Writing took[ms]: " << writeDuration;
+
+        time.start();
+        {
+            for (int i = 0; i < count; i++) {
+                const auto key = QString("key%1").arg(i);
+                if (useDb) {
+                    db.read(key.toStdString());
+                }
+            }
+        }
+        const int readDuration = time.elapsed();
+        if (useDb) {
+            qDebug() << "Reading took[ms]: " << readDuration;
+        } else {
+            qDebug() << "File reading is not implemented.";
+        }
+    }
+
+    void testSizes()
+    {
+        QFileInfo dbInfo(dbPath, "data.mdb");
+        QFileInfo fileInfo(filePath);
+        qDebug() << "Database size [kb]: " << dbInfo.size()/1024;
+        qDebug() << "File size [kb]: " << fileInfo.size()/1024;
+    }
+};
+
+QTEST_MAIN(StorageBenchmark)
+#include "storagebenchmark.moc"