BUG#16857395 - EXCESSIVE MEMORY USAGE AFTER REPEATED TRIGGER

               EXCEPTION HANDLERS
Merge from 5.6 to trunk

Author: Nisha Gopalakrishnan

sql/sp_instr.cc

@@ -461,6 +461,26 @@ LEX *sp_lex_instr::parse_expr(THD *thd, sp_head *sp)
     return NULL;
   }
 
+  // Cleanup current THD from previously held objects before new parsing.
+  cleanup_before_parsing(thd);
+
+  // Cleanup and re-init the lex mem_root for re-parse.
+  free_root(&m_lex_mem_root, MYF(0));
+  init_sql_alloc(PSI_NOT_INSTRUMENTED, &m_lex_mem_root,
+                 MEM_ROOT_BLOCK_SIZE, MEM_ROOT_PREALLOC);
+
+  /*
+    Switch mem-roots. We store the new LEX and its Items in the
+    m_lex_mem_root since it is freed before reparse triggered due to
+    invalidation. This avoids the memory leak in case re-parse is
+    initiated. Also set the statement query arena to the lex mem_root.
+  */
+  MEM_ROOT *execution_mem_root= thd->mem_root;
+  Query_arena parse_arena(&m_lex_mem_root, thd->stmt_arena->state);
+
+  thd->mem_root= &m_lex_mem_root;
+  thd->stmt_arena->set_query_arena(&parse_arena);
+
   // Prepare parser state. It can be done just before parse_sql(), do it here
   // only to simplify exit in case of failure (out-of-memory error).
 
@@ -469,17 +489,6 @@ LEX *sp_lex_instr::parse_expr(THD *thd, sp_head *sp)
   if (parser_state.init(thd, sql_query.c_ptr(), sql_query.length()))
     return NULL;
 
-  // Cleanup current THD from previously held objects before new parsing.
-
-  cleanup_before_parsing(thd);
-
-  // Switch mem-roots. We need to store new LEX and its Items in the persistent
-  // SP-memory (memory which is not freed between executions).
-
-  MEM_ROOT *execution_mem_root= thd->mem_root;
-
-  thd->mem_root= thd->sp_runtime_ctx->sp->get_persistent_mem_root();
-
   // Switch THD::free_list. It's used to remember the newly created set of Items
   // during parsing. We should clean those items after each execution.
 

sql/sp_instr.h

@@ -189,10 +189,21 @@ class sp_lex_instr : public sp_instr
     m_lex_query_tables_own_last(NULL)
   {
     set_lex(lex, is_lex_owner);
+    memset(&m_lex_mem_root, 0, sizeof (MEM_ROOT));
   }
 
   virtual ~sp_lex_instr()
-  { free_lex(); }
+  {
+    free_lex();
+    /*
+      If the instruction is reparsed, m_lex_mem_root was used to allocate the
+      items, then freeing the memroot, frees the items. Hence set the free_list
+      pointer to NULL.
+    */
+    if (alloc_root_inited(&m_lex_mem_root))
+      free_list= NULL;
+    free_root(&m_lex_mem_root, MYF(0));
+  }
 
   /**
     Make a few attempts to execute the instruction.
@@ -354,6 +365,13 @@ class sp_lex_instr : public sp_instr
   virtual void cleanup_before_parsing(THD *thd);
 
 private:
+  /** 
+    Mem-root for storing the LEX-tree during reparse. This
+    mem-root is freed when a reparse is triggered or the stored
+    routine is dropped.
+  */
+  MEM_ROOT m_lex_mem_root;
+
   /// LEX-object.
   LEX *m_lex;
 

sql/sp_rcontext.cc

@@ -23,6 +23,7 @@
 #include "sql_tmp_table.h"                     // create_virtual_tmp_table
 #include "sp_instr.h"
 
+extern "C" void sql_alloc_error_handler(void);
 
 ///////////////////////////////////////////////////////////////////////////
 // sp_rcontext implementation.
@@ -51,8 +52,12 @@ sp_rcontext::~sp_rcontext()
   while (m_activated_handlers.elements())
     delete m_activated_handlers.pop();
 
-  // Leave m_visible_handlers, m_var_items, m_cstack
-  // and m_case_expr_holders untouched.
+  while (m_visible_handlers.elements())
+    delete m_visible_handlers.pop();
+  
+  pop_all_cursors();
+
+  // Leave m_var_items and m_case_expr_holders untouched.
   // They are allocated in mem roots and will be freed accordingly.
 }
 
@@ -158,13 +163,19 @@ bool sp_rcontext::set_return_value(THD *thd, Item **return_value_item)
 bool sp_rcontext::push_cursor(sp_instr_cpush *i)
 {
   /*
-    We should create cursors in the callers arena, as
-    it could be (and usually is) used in several instructions.
+    We should create cursors on the system heap because:
+     - they could be (and usually are) used in several instructions,
+       thus they can not be stored on an execution mem-root;
+     - a cursor can be pushed/popped many times in a loop, having these objects
+       on callers' mem-root would lead to a memory leak in every iteration.
   */
-  sp_cursor *c= new (callers_arena->mem_root) sp_cursor(i);
+  sp_cursor *c= new (std::nothrow) sp_cursor(i);
 
-  if (c == NULL)
+  if (!c)
+  {
+    sql_alloc_error_handler();
     return true;
+  }
 
   m_cstack[m_ccount++]= c;
   return false;
@@ -183,14 +194,21 @@ void sp_rcontext::pop_cursors(uint count)
 bool sp_rcontext::push_handler(sp_handler *handler, uint first_ip)
 {
   /*
-    We should create handler entries in the callers arena, as
-    they could be (and usually are) used in several instructions.
+    We should create handler entries on the system heap because:
+     - they could be (and usually are) used in several instructions,
+       thus they can not be stored on an execution mem-root;
+     - a handler can be pushed/popped many times in a loop, having these
+       objects on callers' mem-root would lead to a memory leak in every
+       iteration.
   */
   sp_handler_entry *he=
-    new (callers_arena->mem_root) sp_handler_entry(handler, first_ip);
+    new (std::nothrow) sp_handler_entry(handler, first_ip);
 
-  if (he == NULL)
+  if (!he)
+  {
+    sql_alloc_error_handler();
     return true;
+  }
 
   return m_visible_handlers.append(he);
 }
@@ -203,7 +221,7 @@ void sp_rcontext::pop_handlers(sp_pcontext *current_scope)
     int handler_level= m_visible_handlers.at(i)->handler->scope->get_level();
 
     if (handler_level >= current_scope->get_level())
-      m_visible_handlers.pop();
+      delete m_visible_handlers.pop();
   }
 }
 
@@ -390,9 +408,16 @@ bool sp_rcontext::handle_sql_condition(THD *thd,
     cur_spi->get_cont_dest() : 0;
 
   /* Add a frame to handler-call-stack. */
-  Handler_call_frame *frame= new Handler_call_frame(found_handler,
-                                                    found_condition,
-                                                    continue_ip);
+  Handler_call_frame *frame= 
+    new (std::nothrow) Handler_call_frame(found_handler,
+                                          found_condition,
+                                          continue_ip);
+  if (!frame)
+  {
+    sql_alloc_error_handler();
+    DBUG_RETURN(false);
+  }
+
   m_activated_handlers.append(frame);
 
   /* End aborted result set. */

sql/sp_rcontext.h

@@ -79,7 +79,7 @@ class sp_rcontext : public Sql_alloc
 private:
   /// This is an auxillary class to store entering instruction pointer for an
   /// SQL-handler.
-  class sp_handler_entry : public Sql_alloc
+  class sp_handler_entry
   {
   public:
     /// Handler definition (from parsing context).
@@ -386,7 +386,7 @@ typedef class st_select_lex_unit SELECT_LEX_UNIT;
 
 /* A mediator between stored procedures and server side cursors */
 
-class sp_cursor : public Sql_alloc
+class sp_cursor
 {
 private:
   /// An interceptor of cursor result set used to implement
@@ -434,6 +434,6 @@ class sp_cursor : public Sql_alloc
 
 private:
   void destroy();
-}; // class sp_cursor : public Sql_alloc
+}; // class sp_cursor
 
 #endif /* _SP_RCONTEXT_H_ */