Uploaded image for project: 'MariaDB Server'
  1. MariaDB Server
  2. MDEV-22721

Remove bloat caused by InnoDB logger class

Details

    Description

      Default implementation of InnoDB logger class uses std::stringstream inside.
      STL streams are famous for generation lots of bloat code after compiling.

      Usage of logger class in hot functions, which is typical for error handling,
      generates a lot of code which is inlined right in the invocation point, and
      99.99% of time this code isn't used. This leads to a huge instruction cache
      waste.

      We can point the compiler at the fact, that any logging is an expremely rare
      operation for database, so the compiler can reduce unnecessary inlining and
      pessimize 'cold' logging branches, meanwhile optimize really hot branches
      and reduce intruction case misses.

      Profit: in our tests, this optimization results in up to 2% performance
      increase in sysbench OLTP PS/RO/RW tests.

      Suggested fix:
      Mark all public logger method and all derived class contructors with 'cold'
      and 'noinline' attibutes.

      Attachments

        Issue Links

          causes

          Bug - A problem which impairs or prevents the functions of the product. MDEV-23183 Infinite loop on page_validate() on corrupted page

          • Blocker - Blocks development and/or testing work, production could not run.
          • Closed
          relates to

          Bug - A problem which impairs or prevents the functions of the product. MDEV-24973 Performance schema duplicates rarely executed code for mutex operations

          • Major - Major loss of function.
          • Closed

          Bug - A problem which impairs or prevents the functions of the product. MDEV-35498 InnoDB logger class causes significant code bloat

          • Major - Major loss of function.
          • Open

          Activity

            Ascending order - Click to sort in descending order
            marko Marko Mäkelä added a comment -

            I would expect that any output to the error log is rarely invoked. I have tried to declare some functions with ATTRIBUTE_COLD and some conditions with UNIV_UNLIKELY, but I have not measured the impact, and surely we could do more. I have not played with the noinline attribute, which could be low-hanging fruit.

            I tentatively set fixVersion to 10.6. If the fix turns out to be a simple addition of function attributes to a few places, then I think that it should be doable in GA versions.

            marko Marko Mäkelä added a comment - I would expect that any output to the error log is rarely invoked. I have tried to declare some functions with ATTRIBUTE_COLD and some conditions with UNIV_UNLIKELY , but I have not measured the impact, and surely we could do more. I have not played with the noinline attribute, which could be low-hanging fruit. I tentatively set fixVersion to 10.6. If the fix turns out to be a simple addition of function attributes to a few places, then I think that it should be doable in GA versions.
            marko Marko Mäkelä added a comment -

            I made an experiment where I added explicit instantiation of the needed ib::logger::operator<<() member functions, added UNIV_UNLIKELY hints to callers, and trimmed some useless parts of output as well.

            I managed to shrink the size of the stripped RelWithDebInfo 10.2 executable that was compiled by GCC 9.3.0 for AMD64 by some 60 KiB.

            Then, I checked the disassembly, and it looks like the explicitly instantiated functions are adding (not removing) bloat, by wrapping simple function calls. With inline function definition but noinline attribute, the savings increased to 86,016 bytes.

            Probably the biggest improvement was achieved by dumbing down the special treatment of fixed-length string constants:

              template<size_t N> logger& operator<<(const char (&rhs)[N])
            		 
              { return *this << static_cast<const char*>(rhs); }

            Maybe it would be even better to revert back to printf-style logging at some point.

            marko Marko Mäkelä added a comment - I made an experiment where I added explicit instantiation of the needed ib::logger::operator<<() member functions, added UNIV_UNLIKELY hints to callers, and trimmed some useless parts of output as well. I managed to shrink the size of the stripped RelWithDebInfo 10.2 executable that was compiled by GCC 9.3.0 for AMD64 by some 60 KiB. Then, I checked the disassembly, and it looks like the explicitly instantiated functions are adding (not removing) bloat, by wrapping simple function calls. With inline function definition but noinline attribute, the savings increased to 86,016 bytes. Probably the biggest improvement was achieved by dumbing down the special treatment of fixed-length string constants: template < size_t N> logger& operator<<( const char (&rhs)[N]) { return * this << static_cast < const char *>(rhs); } Maybe it would be even better to revert back to printf -style logging at some point.

            People

              marko Marko Mäkelä
              dmitriy.philimonov Dmitriy Philimonov
              Votes:
              1 Vote for this issue
              Watchers:
              5 Start watching this issue

              Dates

                Created:
                Updated:
                Resolved:

                Git Integration

                  Error rendering 'com.xiplink.jira.git.jira_git_plugin:git-issue-webpanel'. Please contact your Jira administrators.