Ticket #1660: asyncdb.12631.patch

libs/libmythtv/NuppelVideoPlayer.cpp

@@ -5242 +5242 @@
     using_null_videoout = true;
 
     // clear out any existing seektables
-    m_playbackinfo->ClearPositionMap(MARK_KEYFRAME);
-    m_playbackinfo->ClearPositionMap(MARK_GOP_START);
-    m_playbackinfo->ClearPositionMap(MARK_GOP_BYFRAME);
+    m_playbackinfo->ClearPositionMap(MARK_KEYFRAME,true);
+    m_playbackinfo->ClearPositionMap(MARK_GOP_START,true);
+    m_playbackinfo->ClearPositionMap(MARK_GOP_BYFRAME,true);
 
     if (OpenFile() < 0)
         return(0);

libs/libmythtv/programinfo.h

@@ -220 +220 @@
     // Keyframe positions Map
     void GetPositionMap(frm_pos_map_t &, int type) const;
     void ClearPositionMap(int type) const;
+    void ClearPositionMap(int type, bool sync) const;
     void SetPositionMap(frm_pos_map_t &, int type,
                         long long min_frm = -1, long long max_frm = -1) const;
-    void SetPositionMapDelta(frm_pos_map_t &, int type) const;
+    void SetPositionMapDelta(frm_pos_map_t &, int type);
 
-
     // GUI stuff
     void showDetails(void) const;
     void EditRecording(void);
@@ -322 +322 @@
   private:
     bool ignoreBookmark;
     mutable class ScheduledRecording* record;
+    
+    QString inUseForWhat;
 
-    QString inUseForWhat;
 };
 
 /** \class ProgramList

libs/libmyth/exitcodes.h

@@ -57 +57 @@
 #define BACKEND_BUGGY_EXIT_NO_CAP_CARD            GENERIC_EXIT_START-11
 #define BACKEND_BUGGY_EXIT_NO_CHAN_DATA           GENERIC_EXIT_START-12
 #define BACKEND_EXIT_START                        GENERIC_EXIT_START-12
+#define BACKEND_EXIT_ASYNCDB_ERROR                GENERIC_EXIT_START-13
 
 // mythtranscode
 #define TRANSCODE_EXIT_OK                         GENERIC_EXIT_OK

libs/libmyth/asyncdb.h

@@ +1 @@
+#ifndef ASYNCDB_H_
+#define ASYNCDB_H_
+
+// ANSI C headers
+#include <cstdio>
+#include <cstdlib>
+#include <cerrno>
+
+#include "mythdbcon.h"
+
+#include <qstring.h>
+
+using namespace std;
+
+typedef struct adb_cmd_list {
+    struct adb_cmd_list *next;
+    QString cmd;
+} adb_cmd_list_t;
+
+class AsyncDB
+{
+ public:
+    AsyncDB(void);
+    ~AsyncDB();
+    bool Init(void);
+    void AddCommand(QString);  
+
+ private:
+    pthread_t thread;
+    bool threadRunning;
+    QStringList list;
+//    adb_cmd_list_t *list;
+    QMutex listLock;
+    MSqlQuery query;
+    bool ListRunner(adb_cmd_list_t *);
+
+ protected:
+    static void *StartThread(void *);
+    void Worker(void);
+};
+
+extern AsyncDB *gAsyncDB;
+#endif

libs/libmyth/asyncdb.cpp

@@ +1 @@
+#include "asyncdb.h"
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/mman.h>
+
+AsyncDB *gAsyncDB = NULL;
+#define ADB QString("AsyncDB: ")
+
+/** \class AsyncDB
+ *  \brief This class supports asynchronous database inserts.
+ *
+ *   This class allows us to toss those database queries for which
+ *   we do not require values or status to be run by a separate thread.
+ *   This helps the enocder threads to keep up with the datastream.
+ */
+
+/** \fn AsyncDB
+ *  \brief Initialize the class
+ */
+AsyncDB::AsyncDB(void):
+  query(MSqlQuery::InitCon()), threadRunning(false)
+{
+  list.clear();
+}
+
+/** \fn Init()
+ *  \brief Starts the thread
+ *
+ *   Create a thread and return false if this fails
+ */
+bool AsyncDB::Init(void)
+{
+  int rv;
+  if(  ( rv = pthread_create(&thread, NULL, StartThread, this) ) ) {
+    VERBOSE(VB_IMPORTANT, ADB + QString("Can't start thread"));
+    return false;
+  }
+  threadRunning = true;
+  return(true);
+}
+
+/** \fn StartThread(AsyncDB *)
+ *  \brief Runs the worker function
+ *
+ *   Drop the priority on this thread and invoke the worker function
+ */
+void *AsyncDB::StartThread(void *wotzit)
+{
+  AsyncDB *pi = (AsyncDB *)wotzit;
+  VERBOSE(VB_IMPORTANT,QString("Starting async db thread"));
+  // Loser priority, to avoid problems with recordings.
+  setpriority(PRIO_PROCESS, 0, 3);
+  pi->Worker();
+  return(NULL);
+}
+
+/** \fn AddCommand(QString)
+ *  \brief Adds a database command to the list
+ *
+ *  \param QString   The sql command
+ */
+void AsyncDB::AddCommand(QString cmd)
+{
+  listLock.lock();
+  list.append(cmd);
+  listLock.unlock();
+//  adb_cmd_list_t *item = new adb_cmd_list_t;
+//  item->cmd = cmd;
+//  listLock.lock();
+//  item->next = list;
+//  list = item;
+//  listLock.unlock();
+}
+
+/** \fn ~AsyncDB
+ *  \brief Shut down the thread
+ *
+ *   Add a "done" command to the list to make the thread 
+ *   shutdown and reap it.
+ */
+AsyncDB::~AsyncDB(void)
+{
+  AddCommand(QString("done"));
+  pthread_join(thread, NULL);
+  VERBOSE(VB_IMPORTANT,QString("Ending async db thread"));
+}
+
+/** \fn Worker()
+ *  \brief Run the lists of commands
+ *
+ *   Swap the list for an empty one and call ListRunner
+ *   to execute the commands.
+ */
+void AsyncDB::Worker(void)
+{
+  bool done = false;
+
+  while( ! done ) {
+    if( list.empty() ) {
+      sleep(1);
+    } else {
+      listLock.lock();
+      QStringList mylist = list;
+      list.clear();
+      listLock.unlock();
+      for ( QStringList::Iterator it = mylist.begin(); it != mylist.end(); ++it ) {
+        if( *it == QString("done") ) {
+          done = true;
+          break;
+        }
+        query.prepare(*it);
+        if (!query.exec() || !query.isActive())
+          MythContext::DBError("delta position map insert", 
+                               query);
+      }
+      mylist.clear(); 
+    }
+  }
+//  while( ! done ) {
+//    if( list == NULL ) {
+//      sleep(1);
+//    } else {
+//      listLock.lock();
+//      adb_cmd_list_t *mylist = list;
+//      list = NULL;
+//      listLock.unlock();
+//      done = ListRunner(mylist);
+//    }
+//  }
+}
+
+/** \fn ListRunner( adb_cmd_list_t * )
+ *  \brief Execute the accumulated commands
+ *
+ *   Standard recursive routine. Shoot down to the end of the
+ *   list and as we return back execute the commands and clean
+ *   up the objects. This maintains order, since the newest 
+ *   commands are at the head of the list.
+ *
+ *   If we find the command "done" return true.
+ *
+ *  \param adb_cmd_list_t*  The rest of the list
+ */
+bool AsyncDB::ListRunner( adb_cmd_list_t *list ) {
+  bool done = false;
+  if( list != NULL ) {
+    done = ListRunner(list->next);
+    if( list->cmd == QString("done") ) {
+          done = true;
+    } else {
+      query.prepare(list->cmd);
+      if (!query.exec() || !query.isActive())
+        MythContext::DBError("async command failed", 
+                             query);
+    }
+    delete list->cmd;
+    delete list;
+  }
+  return( done );
+}
+

programs/mythtranscode/main.cpp

@@ -540 +545 @@
 {
     if (pginfo && ! mapfile)
     {
-        pginfo->ClearPositionMap(MARK_KEYFRAME);
-        pginfo->ClearPositionMap(MARK_GOP_START);
+        pginfo->ClearPositionMap(MARK_KEYFRAME, true);
+        pginfo->ClearPositionMap(MARK_GOP_START, true);
         pginfo->SetPositionMap(posMap, MARK_GOP_BYFRAME);
     }
     else if (mapfile)

programs/mythbackend/main.cpp

@@ -36 +36 @@
 #include "libmythtv/jobqueue.h"
 #include "libmythtv/storagegroup.h"
 #include "libmythupnp/mediaserver.h"
+#include "libmyth/asyncdb.h"
 
 #include "upnpcdstv.h"
 #include "upnpcdsmusic.h"

libs/libmythtv/programinfo.cpp

@@ -17 +17 @@
 #include "util.h"
 #include "mythcontext.h"
 #include "dialogbox.h"
+#include "asyncdb.h"
 #include "remoteutil.h"
 #include "jobqueue.h"
 #include "mythdbcon.h"
@@ -1812 +1813 @@
 {
     filesize = fsize;
 
-    MSqlQuery query(MSqlQuery::InitCon());
-    query.prepare("UPDATE recorded SET filesize = :FILESIZE"
-                  " WHERE chanid = :CHANID"
-                  " AND starttime = :STARTTIME ;");
-    query.bindValue(":FILESIZE", longLongToString(fsize));
-    query.bindValue(":CHANID", chanid);
-    query.bindValue(":STARTTIME", recstartts);
+    QString query = QString("UPDATE recorded SET filesize = %1"
+                            " WHERE chanid = %2"
+                            " AND starttime = \"%3\" ;")
+      .arg(longLongToString(fsize))
+      .arg(chanid)
+      .arg(recstartts.toString("yyyyMMddhhmmss"));
     
-    if (!query.exec() || !query.isActive())
-        MythContext::DBError("File size update", 
-                             query);
+    gAsyncDB->AddCommand(query);
 }
 
 /** \fn ProgramInfo::GetFilesize(void)
@@ -2595 +2593 @@
 
 void ProgramInfo::ClearPositionMap(int type) const
 {
+    QString query;
+  
+    if (isVideo)
+    {
+        query = QString("DELETE FROM filemarkup"
+                        " WHERE filename = \"%1\"")
+        .arg(pathname);
+    }
+    else
+    {
+        query = QString("DELETE FROM recordedseek"
+                      " WHERE chanid = %1"
+                      " AND starttime = \"%2\"")
+        .arg(chanid)
+        .arg(recstartts.toString("yyyyMMddhhmmss"));
+    }
+    query += QString(" AND type = %1 ;").arg(type);
+                               
+    /* Hand it to the async thread */
+    gAsyncDB->AddCommand(query);
+}
+
+void ProgramInfo::ClearPositionMap(int type, bool sync) const
+{
     MSqlQuery query(MSqlQuery::InitCon());
   
     if (isVideo)
@@ -2712 +2734 @@
 }
 
 void ProgramInfo::SetPositionMapDelta(frm_pos_map_t &posMap,
-                                      int type) const
+                                      int type)
 {
     QMap<long long, long long>::Iterator i;
-    MSqlQuery query(MSqlQuery::InitCon());
+    QString insert;
+
+    if( posMap.isEmpty() )
+      return;
+
+    if (isVideo)
+      {
+        insert = QString("INSERT INTO filemarkup"
+                         " (filename, mark, type, offset)"
+                         " VALUES");
+      } 
+    else 
+      {
+        insert = QString("INSERT INTO recordedseek"
+                         " (chanid, starttime, mark, type, offset)"
+                         " VALUES");
+      }
+    QString sep = " ";
 
+    /* Assemble these these updates into a single multi-row insert 
+     * statement -- much more efficient */
     for (i = posMap.begin(); i != posMap.end(); ++i)
     {
         long long frame = i.key();
@@ -2731 +2772 @@
         QString offset_str = tempc;
 
         if (isVideo)
-        {
-            query.prepare("INSERT INTO filemarkup"
-                          " (filename, mark, type, offset)"
-                          " VALUES"
-                          " ( :PATH , :MARK , :TYPE , :OFFSET );");
-            query.bindValue(":PATH", pathname);
-        }
-        else
-        {
-            query.prepare("INSERT INTO recordedseek"
-                          " (chanid, starttime, mark, type, offset)"
-                          " VALUES"
-                          " ( :CHANID , :STARTTIME , :MARK , :TYPE , :OFFSET );");
-            query.bindValue(":CHANID", chanid);
-            query.bindValue(":STARTTIME", recstartts);
-        }
-        query.bindValue(":MARK", frame_str);
-        query.bindValue(":TYPE", type);
-        query.bindValue(":OFFSET", offset_str);
-        
-        if (!query.exec() || !query.isActive())
-            MythContext::DBError("delta position map insert", 
-                                 query);
-    }
+          {
+            insert += sep + QString("( \"%1\", %2, %3, %4 )")
+              .arg(pathname).arg(i.key()).arg(type).arg(i.data());
+          }
+          else
+          {
+            insert += sep + QString("( %1 , \"%2\" , %3 , %4 , %5 )")
+              .arg(chanid).arg(recstartts.toString("yyyyMMddhhmmss"))
+              .arg(i.key()).arg(type).arg(i.data());
+          }
+        sep = ",";
+      }
+
+    insert += QString(";");
+    /* Hand it to the async thread */
+    gAsyncDB->AddCommand(insert);
 }
 
 /** \fn ProgramInfo::ReactivateRecording(void)

libs/libmyth/libmyth.pro

@@ -20 +20 @@
 HEADERS += langsettings.h audiooutputnull.h mythsocket.h
 HEADERS += DisplayResScreen.h util-x11.h mythdeque.h qmdcodec.h
 HEADERS += exitcodes.h virtualkeyboard.h mythobservable.h mythevent.h
+HEADERS += asyncdb.h
 HEADERS += mythexp.h mythpluginapi.h
 
 SOURCES += dialogbox.cpp lcddevice.cpp mythcontext.cpp mythwidgets.cpp 
@@ -33 +34 @@
 SOURCES += langsettings.cpp mythdbcon.cpp audiooutputnull.cpp
 SOURCES += DisplayResScreen.cpp util-x11.cpp qmdcodec.cpp
 SOURCES += virtualkeyboard.cpp mythobservable.cpp mythsocket.cpp
+SOURCES += asyncdb.cpp
 
 INCLUDEPATH += ../libmythsamplerate ../libmythsoundtouch ../.. ../
 DEPENDPATH += ../libmythsamplerate ../libmythsoundtouch ../ ../libmythui
@@ -59 +61 @@
 inc.files += visual.h volumebase.h output.h langsettings.h qmdcodec.h
 inc.files += exitcodes.h mythconfig.h mythconfig.mak virtualkeyboard.h
 inc.files += mythevent.h mythobservable.h mythsocket.h
+inc.files += asyncdb.h
 inc.files += mythexp.h mythpluginapi.h
 
 cygwin:QMAKE_LFLAGS_SHLIB += -Wl,--noinhibit-exec