Optimise dumping while using the logger backend

Change-Id: I78ae67e8800bf8aed962a859f7ccd2afdddbf39f

diff --git a/src/libdlogutil/fdi_logger.c b/src/libdlogutil/fdi_logger.c
index 77045db..30d690c 100644 (file)
--- a/src/libdlogutil/fdi_logger.c
+++ b/src/libdlogutil/fdi_logger.c
@@ -296,6 +296,17 @@ static dlogutil_entry_s *logger_extract_entry(struct fd_info *fdi)
 
        dlogutil_entry_s *const ret = lpd->entry;
        lpd->entry = NULL;
+
+       /* Try to read a new entry immediately, so that the buffer will not become empty if possible.
+        * Since this is a nonblocking FD, we don't even have to make sure an entry is available.
+        * We ignore the result of the read. This is not an issue, because it can be either:
+        * 1. Number of bytes read, which is not useful to us,
+        * 2. Zero meaning EOF, which is returned in a different way (via the .eof method),
+        * 3. A negative number meaning error, which is not a big deal, since this is just
+        *    an optimisation --- if the error repeats, we will see this when the .read method
+        *    is called directly. */
+       logger_read(fdi);
+
        return ret;
 }
 

diff --git a/src/tests/fdi_logger.c b/src/tests/fdi_logger.c
index 38fba25..7072b17 100644 (file)
--- a/src/tests/fdi_logger.c
+++ b/src/tests/fdi_logger.c
@@ -195,9 +195,11 @@ int main()
 
        for (size_t i = 0; i < NELEMS(READS) + 15; ++i) {
                assert(!ops_logger.has_log(&fdi));
+               fail_read = true;
                assert(NULL == ops_logger.extract_entry(&fdi));
                assert(NULL == ops_logger.peek_entry(&fdi));
                assert(NULL == ops_logger.extract_entry(&fdi));
+               fail_read = false;
                fail_malloc = !(rand() % 4) * 3;
                ops_logger.read(&fdi);
                if (!fail_malloc && i < NELEMS(READS) && READS[i] > sizeof(struct android_logger_entry)) {
@@ -206,13 +208,17 @@ int main()
                        const dlogutil_entry_s *const le = ops_logger.peek_entry(&fdi);
                        assert(le);
                        assert(le == ops_logger.peek_entry(&fdi));
+                       fail_read = true;
                        assert(le == ops_logger.extract_entry(&fdi));
+                       fail_read = false;
                        free((dlogutil_entry_s *) le);
                }
                fail_malloc = 0;
                assert(!ops_logger.has_log(&fdi));
                assert(NULL == ops_logger.peek_entry(&fdi));
+               fail_read = true;
                assert(NULL == ops_logger.extract_entry(&fdi));
+               fail_read = false;
        }
 
        ops_logger.destroy(&fdi);