MDEV-36024 preparation: Shrink mtr_buf_t

mtr_t::get_log_size(): Remove.

mtr_t::crc32c(): New function: compute CRC-32C and determine the size,
including the sequence byte and the CRC-32C.

mtr_t::encrypt(): Return the size, similar to crc32c().

mtr_t::log_file_op(): Return the size written.

fil_name_write(): Remove. Let us invoke mtr_t::log_file_op() directly.

fil_names_clear(): Keep track of the available size without
invoking mtr_t::get_log_size().

mtr_buf_t::m_size: Remove.

mtr_buf_t::list_t: Use ilist instead of sized_ilist.

mtr_buf_t::for_each_block(): Remove. Let us allow iteration via
begin() and end(), without any lambda function objects.

Author: dr-m

storage/innobase/fil/fil0fil.cc

@@ -1423,12 +1423,15 @@ fil_space_t *fil_space_t::get(uint32_t id) noexcept
 @param type           file operation
 @param first_page_no  first page number in the file
 @param path           file path
-@param new_path       new file path for type=FILE_RENAME */
-inline void mtr_t::log_file_op(mfile_type_t type, uint32_t space_id,
-			       const char *path, const char *new_path)
+@param new_path       new file path for type=FILE_RENAME
+@return number of bytes written */
+inline size_t mtr_t::log_file_op(mfile_type_t type, uint32_t space_id,
+                                 const char *path, const char *new_path)
+  noexcept
 {
   ut_ad((new_path != nullptr) == (type == FILE_RENAME));
   ut_ad(!(byte(type) & 15));
+  ut_ad(!is_predefined_tablespace(space_id));
 
   /* fil_name_parse() requires that there be at least one path
   separator and that the file path end with ".ibd". */
@@ -1437,7 +1440,7 @@ inline void mtr_t::log_file_op(mfile_type_t type, uint32_t space_id,
 
   m_modifications= true;
   if (!is_logged())
-    return;
+    return 0;
   m_last= nullptr;
 
   const size_t len= strlen(path);
@@ -1469,25 +1472,16 @@ inline void mtr_t::log_file_op(mfile_type_t type, uint32_t space_id,
 
   m_log.close(end);
 
-  if (new_path)
+  if (new_len)
   {
     ut_ad(strchr(new_path, '/'));
     m_log.push(reinterpret_cast<const byte*>(path), uint32_t(len + 1));
     m_log.push(reinterpret_cast<const byte*>(new_path), uint32_t(new_len - 1));
   }
   else
     m_log.push(reinterpret_cast<const byte*>(path), uint32_t(len));
-}
 
-/** Write FILE_MODIFY for a file.
-@param[in]	space_id	tablespace id
-@param[in]	name		tablespace file name
-@param[in,out]	mtr		mini-transaction */
-static void fil_name_write(uint32_t space_id, const char *name,
-                           mtr_t *mtr)
-{
-  ut_ad(!is_predefined_tablespace(space_id));
-  mtr->log_file_op(FILE_MODIFY, space_id, name);
+  return end - log_ptr + len + new_len;
 }
 
 fil_space_t *fil_space_t::drop(uint32_t id, pfs_os_file_t *detached_handle)
@@ -2986,9 +2980,8 @@ ATTRIBUTE_NOINLINE ATTRIBUTE_COLD void mtr_t::name_write() noexcept
 
   mtr_t mtr;
   mtr.start();
-  fil_name_write(m_user_space->id,
-                 UT_LIST_GET_FIRST(m_user_space->chain)->name,
-                 &mtr);
+  mtr.log_file_op(FILE_MODIFY, m_user_space->id,
+                  UT_LIST_GET_FIRST(m_user_space->chain)->name);
   mtr.commit_files();
 }
 
@@ -3005,14 +2998,18 @@ ATTRIBUTE_COLD lsn_t fil_names_clear(lsn_t lsn) noexcept
 	ut_ad(log_sys.is_latest());
 
 	mtr.start();
+	constexpr size_t budget = recv_sys.MTR_SIZE_MAX - (3 + 5);
+	size_t budget_left = budget;
 
 	for (auto it = fil_system.named_spaces.begin();
 	     it != fil_system.named_spaces.end(); ) {
-		if (mtr.get_log_size() + strlen(it->chain.start->name)
-		    >= recv_sys.MTR_SIZE_MAX - (3 + 5)) {
+		const char* const name = it->chain.start->name;
+
+		if (strlen(name) >= budget_left) {
 			/* Prevent log parse buffer overflow */
 			mtr.commit_files();
 			mtr.start();
+			budget_left = budget;
 		}
 
 		auto next = std::next(it);
@@ -3033,8 +3030,9 @@ ATTRIBUTE_COLD lsn_t fil_names_clear(lsn_t lsn) noexcept
 		where max_lsn turned nonzero), we could avoid the
 		fil_names_write() call if min_lsn > lsn. */
 		ut_ad(UT_LIST_GET_LEN((*it).chain) == 1);
-		fil_name_write((*it).id, UT_LIST_GET_FIRST((*it).chain)->name,
-			       &mtr);
+		size_t s = mtr.log_file_op(FILE_MODIFY, (*it).id, name);
+		ut_ad(s <= budget_left);
+		budget_left -= s;
 		it = next;
 	}
 

storage/innobase/include/dyn0buf.h

@@ -155,13 +155,12 @@ class mtr_buf_t {
 		friend class mtr_buf_t;
 	};
 
-	typedef sized_ilist<block_t> list_t;
+	typedef ilist<block_t> list_t;
 
 	/** Default constructor */
 	mtr_buf_t()
 		:
-		m_heap(),
-		m_size()
+		m_heap()
 	{
 		push_back(&m_first_block);
 	}
@@ -183,11 +182,10 @@ class mtr_buf_t {
 			m_list.clear();
 			m_list.push_back(m_first_block);
 		} else {
+			ut_ad(front() == &m_first_block);
+			ut_ad(back() == &m_first_block);
 			m_first_block.init();
-			ut_ad(m_list.size() == 1);
 		}
-
-		m_size = 0;
 	}
 
 	/**
@@ -217,13 +215,7 @@ class mtr_buf_t {
 	void close(const byte* ptr)
 	{
 		ut_ad(!m_list.empty());
-		block_t*	block = back();
-
-		m_size -= block->used();
-
-		block->close(ptr);
-
-		m_size += block->used();
+		back()->close(ptr);
 	}
 
 	/**
@@ -241,8 +233,6 @@ class mtr_buf_t {
 
 		block = has_space(size) ? back() : add_block();
 
-		m_size += size;
-
 		/* See ISO C++03 14.2/4 for why "template" is required. */
 
 		return(block->template push<Type>(size));
@@ -264,41 +254,8 @@ class mtr_buf_t {
 		}
 	}
 
-	/**
-	Returns the size of the total stored data.
-	@return	data size in bytes */
-	ulint size() const
-		MY_ATTRIBUTE((warn_unused_result))
-	{
-#ifdef UNIV_DEBUG
-		ulint	total_size = 0;
-
-		for (list_t::iterator it = m_list.begin(), end = m_list.end();
-		     it != end; ++it) {
-			total_size += it->used();
-		}
-
-		ut_ad(total_size == m_size);
-#endif /* UNIV_DEBUG */
-		return(m_size);
-	}
-
-	/**
-	Iterate over each block and call the functor.
-	@return	false if iteration was terminated. */
-	template <typename Functor>
-	bool for_each_block(const Functor& functor) const
-	{
-		for (list_t::iterator it = m_list.begin(), end = m_list.end();
-		     it != end; ++it) {
-
-			if (!functor(&*it)) {
-				return false;
-			}
-		}
-
-		return(true);
-	}
+	list_t::const_iterator begin() const { return m_list.begin(); }
+	list_t::const_iterator end() const { return m_list.end(); }
 
 	/**
 	@return the first block */
@@ -377,9 +334,6 @@ class mtr_buf_t {
 	/** Allocated blocks */
 	list_t			m_list;
 
-	/** Total size used by all blocks */
-	ulint			m_size;
-
 	/** The default block, should always be the first element. This
 	is for backwards compatibility and to avoid an extra heap allocation
 	for small REDO log records */

storage/innobase/include/mtr0mtr.h

@@ -435,10 +435,8 @@ struct mtr_t {
     m_memo.emplace_back(mtr_memo_slot_t{object, type});
   }
 
-  /** @return the size of the log is empty */
-  size_t get_log_size() const { return m_log.size(); }
   /** @return whether the log and memo are empty */
-  bool is_empty() const { return !get_savepoint() && !get_log_size(); }
+  bool is_empty() const { return !get_savepoint() && m_log.empty(); }
 
   /** Write an OPT_PAGE_CHECKSUM record. */
   inline void page_checksum(const buf_page_t &bpage);
@@ -618,10 +616,11 @@ struct mtr_t {
   @param type           file operation
   @param space_id       tablespace identifier
   @param path           file path
-  @param new_path       new file path for type=FILE_RENAME */
-  inline void log_file_op(mfile_type_t type, uint32_t space_id,
-                          const char *path,
-                          const char *new_path= nullptr);
+  @param new_path       new file path for type=FILE_RENAME
+  @return number of bytes written */
+  inline size_t log_file_op(mfile_type_t type, uint32_t space_id,
+                            const char *path,
+                            const char *new_path= nullptr) noexcept;
 
   /** Add freed page numbers to freed_pages */
   void add_freed_offset(fil_space_t *space, uint32_t page)
@@ -692,8 +691,13 @@ struct mtr_t {
   tablespace was modified for the first time since fil_names_clear(). */
   ATTRIBUTE_NOINLINE ATTRIBUTE_COLD void name_write() noexcept;
 
-  /** Encrypt the log */
-  ATTRIBUTE_NOINLINE void encrypt();
+  /** Encrypt the log
+  @return the total size in bytes, excluding the 8-byte nonce */
+  ATTRIBUTE_NOINLINE size_t encrypt() noexcept;
+
+  /** Calculate m_crc of m_log.
+  @return the total size in bytes, including the 5-byte trailer and CRC-32C */
+  ATTRIBUTE_NOINLINE size_t crc32c() noexcept;
 
   /** Commit the mini-transaction log.
   @tparam pmem log_sys.is_mmap()

storage/innobase/log/log0crypt.cc

@@ -558,11 +558,10 @@ static size_t log_encrypt_buf(byte iv[MY_AES_BLOCK_SIZE],
   return 0;
 }
 
-/** Encrypt the log */
-ATTRIBUTE_NOINLINE void mtr_t::encrypt()
+ATTRIBUTE_NOINLINE size_t mtr_t::encrypt() noexcept
 {
   ut_ad(log_sys.format == log_t::FORMAT_ENC_10_8);
-  ut_ad(m_log.size());
+  ut_ad(!m_log.empty());
 
   alignas(8) byte iv[MY_AES_BLOCK_SIZE];
 
@@ -572,35 +571,36 @@ ATTRIBUTE_NOINLINE void mtr_t::encrypt()
   byte *dst= static_cast<byte*>(alloca(srv_page_size));
   mach_write_to_8(iv, m_commit_lsn);
   mtr_buf_t::block_t *start= nullptr;
-  size_t size= 0, start_size= 0;
+  size_t size= 0, start_size= 0, log_size= 5;
   m_crc= 0;
 
-  m_log.for_each_block([&](mtr_buf_t::block_t *b)
+  for (mtr_buf_t::block_t &b : m_log)
   {
     ut_ad(t - tmp + size <= srv_page_size);
-    byte *buf= b->begin();
+    log_size+= b.used();
+    byte *buf= b.begin();
     if (!start)
     {
     parse:
       ut_ad(t == tmp);
-      size= log_encrypt_buf(iv, t, buf, b->end());
+      size= log_encrypt_buf(iv, t, buf, b.end());
       if (!size)
       {
         ut_ad(t == tmp);
         start_size= 0;
       }
       else
       {
-        start= b;
+        start= &b;
         start_size= t - tmp;
       }
-      m_crc= my_crc32c(m_crc, buf, b->end() - buf - start_size);
+      m_crc= my_crc32c(m_crc, buf, b.end() - buf - start_size);
     }
-    else if (size > b->used())
+    else if (size > b.used())
     {
-      ::memcpy(t, buf, b->used());
-      t+= b->used();
-      size-= b->used();
+      ::memcpy(t, buf, b.used());
+      t+= b.used();
+      size-= b.used();
     }
     else
     {
@@ -620,22 +620,22 @@ ATTRIBUTE_NOINLINE void mtr_t::encrypt()
       /* Copy the encrypted data back to the log snippets. */
       ::memcpy(start->end() - start_size, dst, start_size);
       t= dst + start_size;
-      for (ilist<mtr_buf_t::block_t>::iterator i(start); &*++i != b;)
+      for (ilist<mtr_buf_t::block_t>::iterator i(start); &*++i != &b;)
       {
         const size_t l{i->used()};
         ::memcpy(i->begin(), t, l);
         t+= l;
       }
-      ::memcpy(b->begin(), t, size);
+      ::memcpy(b.begin(), t, size);
       ut_ad(t + size == dst + len);
       t= tmp;
       start= nullptr;
       goto parse;
     }
-    return true;
-  });
+  }
 
   ut_ad(t == tmp);
   ut_ad(!start);
   ut_ad(!size);
+  return log_size;
 }