Ticket #9458: 100-posix_fadvise_fixes_v2.patch

libs/libmythtv/fileringbuffer.cpp

@@ -100 +100 @@
 
     if (fd2 >= 0)
     {
+        posix_fadvise(fd2, 0, 0, POSIX_FADV_DONTNEED);
         close(fd2);
         fd2 = -1;
     }
@@ -252 +253 @@
                 {
                     if (0 == lseek(fd2, 0, SEEK_SET))
                     {
-                        posix_fadvise(fd2, 0, 0, POSIX_FADV_SEQUENTIAL);
-                        posix_fadvise(fd2, 0, 1*1024*1024, POSIX_FADV_WILLNEED);
+                        posix_fadvise(fd2, 0, 0, POSIX_FADV_SEQUENTIAL);
                         lasterror = 0;
                         break;
                     }
@@ -601 +601 @@
                 else
                 {
                     ret = lseek64(fd2, internalreadpos, SEEK_SET);
-                    posix_fadvise(fd2, 0,
-                                  internalreadpos, POSIX_FADV_DONTNEED);
-                    posix_fadvise(fd2, internalreadpos,
-                                  1*1024*1024, POSIX_FADV_WILLNEED);
                 }
                 VERBOSE(VB_FILE, LOC +
                         QString("Seek to %1 from ignore pos %2 returned %3")
@@ -687 +683 @@
             else
             {
                 ret = lseek64(fd2, ignorereadpos, SEEK_SET);
-                posix_fadvise(fd2, ignorereadpos, 250000, POSIX_FADV_WILLNEED);
             }
 
             if (ret < 0)
@@ -752 +747 @@
     else
     {
         ret = lseek64(fd2, pos, whence);
-        if (ret >= 0)
-        {
-            posix_fadvise(fd2, 0,   ret,         POSIX_FADV_DONTNEED);
-            posix_fadvise(fd2, ret, 1*1024*1024, POSIX_FADV_WILLNEED);
-        }
     }
 
     if (ret >= 0)
     {
         readpos = ret;
-        
+
         ignorereadpos = -1;
 
         if (readaheadrunning)

libs/libmythtv/ringbuffer.cpp

@@ -784 +784 @@
             poslock.lockForWrite();
             rbwlock.lockForWrite();
             internalreadpos += read_return;
-            off_t donotneed = internalreadpos;
             rbwpos = (rbwpos + read_return) % kBufferSize;
             VERBOSE(VB_FILE|VB_EXTRA,
                     LOC + QString("rbwpos += %1K requested %2K in read")
@@ -792 +791 @@
             rbwlock.unlock();
             poslock.unlock();
 
-            if (fd2 >=0 && donotneed > 0)
-                posix_fadvise(fd2, 0, donotneed, POSIX_FADV_DONTNEED);
+            if (fd2 >=0 && read_return > 0)
+            {
+                posix_fadvise(fd2, (lseek(fd2, 0, SEEK_CUR) - read_return),
+                              read_return, POSIX_FADV_DONTNEED);
+            }
         }
 
         int used = kBufferSize - ReadBufFree();
@@ -1017 +1019 @@
             else
             {
                 lseek64(fd2, old_pos, SEEK_SET);
-                posix_fadvise(fd2, old_pos, 1*1024*1024, POSIX_FADV_WILLNEED);
             }
         }
         else
@@ -1106 +1107 @@
             VERBOSE(VB_FILE|VB_EXTRA, LOC + loc_desc +
                     QString(": ReadDirect checksum %1")
                     .arg(qChecksum((char*)buf,count)));
+
+            if (fd2 >=0 && ret > 0)
+            {
+                posix_fadvise(fd2, (lseek(fd2, 0, SEEK_CUR) - ret),
+                              ret, POSIX_FADV_DONTNEED);
+            }
+
             rwlock.unlock();
             return ret;
         }

libs/libmythtv/ThreadedFileWriter.cpp

@@ -217 +217 @@
         Flush();
         in_dtor = true; /* tells child thread to exit */
 
+        bufferHasData.wakeAll();
+        pthread_join(writer, NULL);
+
         bufferSyncWait.wakeAll();
         pthread_join(syncer, NULL);
 
-        bufferHasData.wakeAll();
-        pthread_join(writer, NULL);
         close(fd);
         fd = -1;
     }
@@ -385 +386 @@
 {
     if (fd >= 0)
     {
-        /// Toss any data the kernel wrote to disk on it's own from
-        /// the cache, so we don't get penalized for preserving it
-        /// during the sync.
-        (void) posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
-
 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
         // fdatasync tries to avoid updating metadata, but will in
         // practice always update metadata if any data is written
@@ -398 +394 @@
 #else
         fsync(fd);
 #endif
+        buflock.lock();
+        off_t write_position = m_file_wpos;
+        buflock.unlock();
 
-        // Toss any data we just synced from cache, so we don't
-        // get penalized for it between now and the next sync.
-        (void) posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
+        const int may_need = (5 * 4 * 1024 *1024);
+        if (in_dtor)
+        {
+            // invalidate remaining portion of the pagecache
+            posix_fadvise(fd, m_file_sync,
+                              write_position - m_file_sync,
+                              POSIX_FADV_DONTNEED);
+        }
+        else if (write_position > may_need)
+        {
+            // leave portion of the file in pagecache because livetv
+            // playback may need it very soon. This will reduce disk
+            // io during livetv playback and decrease time required
+            // to open next file when player switching/jumping
+            // to next program. The size of may_need has been choosed
+            // as 5 seconds of 35mbit playback.
+            posix_fadvise(fd, m_file_sync,
+                              write_position - may_need - m_file_sync,
+                              POSIX_FADV_DONTNEED);
+            m_file_sync = write_position - may_need;
+        }
     }
 }