Bug#17473077 EVER INCREASING MEMORY USAGE REPORTED FOR EVENT SCHEDULER

Before this fix, statistics for the memory instrumentation
were inaccurate, in the following scenario:

At T1, thread A allocates some memory, of size N
At T2, thread A gives ownership of the allocated memory to thread B
At T3, thread B de allocates the block memory, of size N

The event at T1 is instrumented with the performance schema,
and an allocation of size N is counted against thread A.

The event at T2 is not instrumented.
The performance schema is unaware of the memory transfer.

The event at T3 is instrumented with the performance schema,
and a de allocation of size N is counted against thread B.

The problem with this approach is with statistics maintained by thread.

When the same code is executed many times (in a loop with the event
scheduler),
- thread A appears to use an ever increasing amount of memory
- thread B appears to consume an ever increasing amount of memory
- the global statistics for the server diverge.

To resolve this bug, two different fixes are implemented.

Which fix to use depends on the nature of the instrumented memory.

FIX NUMBER 1

For memory instruments that are by nature measuring a global resource,
there is no point in maintaining per thread (and per account, per user, per
host) statistics.

A typical example of such usage are shared, global structures,
like the query cache.

For these memory instruments, the performance schema now supports
defining the instrument with PSI_GLOBAL_FLAG.

For instruments defined as global, the performance schema
only maintains the global memory statistics.

In this case, nothing needs to be done for event T2,
as instrumentation for the allocation (T1) and de allocation (T3)
is enough to maintain everything.

FIX NUMBER 2

For memory instruments that are by nature measuring a local resource,
maintaining statistics per thread is desirable.

In order to do so, the performance schema needs to be told about event T2,
which is now instrumented explicitly in the code.

A new entry point in the instrumentation, PSI_MEMORY_CALL(memory_claim),
is used to instrument the change of ownership of a block of memory.

When a thread in the server allocates a data structure,
starts a child thread, and gives ownership of the memory structure to the
child, the code in the child thread now needs to claim ownership of the
data.

With this added instrumentation, performance schema statistics now
reflect more closely how memory is actually used in the server.

Various claim_memory_ownership() methods are implemented to support this.

Author: marcalff

include/hash.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -86,6 +86,7 @@ my_bool _my_hash_init(HASH *hash, uint growth_size, CHARSET_INFO *charset,
                       size_t key_length, my_hash_get_key get_key,
                       void (*free_element)(void*),
                       uint flags);
+void my_hash_claim(HASH *tree);
 void my_hash_free(HASH *tree);
 void my_hash_reset(HASH *hash);
 uchar *my_hash_element(HASH *hash, ulong idx);

include/my_sys.h

@@ -752,6 +752,7 @@ extern my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void *element);
 extern void *alloc_dynamic(DYNAMIC_ARRAY *array);
 extern void *pop_dynamic(DYNAMIC_ARRAY*);
 extern void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint array_index);
+extern void claim_dynamic(DYNAMIC_ARRAY *array);
 extern void delete_dynamic(DYNAMIC_ARRAY *array);
 extern void freeze_size(DYNAMIC_ARRAY *array);
 static inline void reset_dynamic(DYNAMIC_ARRAY *array)
@@ -778,6 +779,7 @@ extern void init_alloc_root(PSI_memory_key key,
 			    size_t pre_alloc_size);
 extern void *alloc_root(MEM_ROOT *mem_root, size_t Size);
 extern void *multi_alloc_root(MEM_ROOT *mem_root, ...);
+extern void claim_root(MEM_ROOT *root);
 extern void free_root(MEM_ROOT *root, myf MyFLAGS);
 extern void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
                                 size_t prealloc_size);

include/mysql.h.pp

@@ -99,6 +99,7 @@
 void my_net_local_init(NET *net);
 void net_end(NET *net);
 void net_clear(NET *net, my_bool check_buffer);
+void net_claim_memory_ownership(NET *net);
 my_bool net_realloc(NET *net, size_t length);
 my_bool net_flush(NET *net);
 my_bool my_net_write(NET *net,const unsigned char *packet, size_t len);
@@ -253,6 +254,7 @@
 #include "my_alloc.h"
 #include <mysql/psi/psi_memory.h>
 #include "psi_base.h"
+struct PSI_thread;
 typedef unsigned int PSI_memory_key;
 typedef struct st_used_mem
 {

include/mysql/psi/psi.h

@@ -2638,6 +2638,8 @@ struct PSI_v1
   memory_alloc_v1_t memory_alloc;
   /** @sa memory_realloc_v1_t. */
   memory_realloc_v1_t memory_realloc;
+  /** @sa memory_claim_v1_t. */
+  memory_claim_v1_t memory_claim;
   /** @sa memory_free_v1_t. */
   memory_free_v1_t memory_free;
 

include/mysql/psi/psi_abi_v0.h.pp

@@ -2,6 +2,7 @@
 #include "psi_base.h"
 #include "psi_memory.h"
 #include "psi_base.h"
+struct PSI_thread;
 typedef unsigned int PSI_memory_key;
 C_MODE_START
 struct MDL_key;

include/mysql/psi/psi_abi_v1.h.pp

@@ -2,6 +2,7 @@
 #include "psi_base.h"
 #include "psi_memory.h"
 #include "psi_base.h"
+struct PSI_thread;
 typedef unsigned int PSI_memory_key;
 struct PSI_memory_info_v1
 {
@@ -13,11 +14,13 @@
 typedef void (*register_memory_v1_t)
   (const char *category, struct PSI_memory_info_v1 *info, int count);
 typedef PSI_memory_key (*memory_alloc_v1_t)
-  (PSI_memory_key key, size_t size);
+  (PSI_memory_key key, size_t size, struct PSI_thread ** owner);
 typedef PSI_memory_key (*memory_realloc_v1_t)
-  (PSI_memory_key key, size_t old_size, size_t new_size);
+  (PSI_memory_key key, size_t old_size, size_t new_size, struct PSI_thread ** owner);
+typedef PSI_memory_key (*memory_claim_v1_t)
+  (PSI_memory_key key, size_t size, struct PSI_thread ** owner);
 typedef void (*memory_free_v1_t)
-  (PSI_memory_key key, size_t size);
+  (PSI_memory_key key, size_t size, struct PSI_thread * owner);
 typedef struct PSI_memory_info_v1 PSI_memory_info;
 C_MODE_START
 struct MDL_key;
@@ -805,6 +808,7 @@
   register_memory_v1_t register_memory;
   memory_alloc_v1_t memory_alloc;
   memory_realloc_v1_t memory_realloc;
+  memory_claim_v1_t memory_claim;
   memory_free_v1_t memory_free;
   unlock_table_v1_t unlock_table;
   create_metadata_lock_v1_t create_metadata_lock;

include/mysql/psi/psi_abi_v2.h.pp

@@ -2,6 +2,7 @@
 #include "psi_base.h"
 #include "psi_memory.h"
 #include "psi_base.h"
+struct PSI_thread;
 typedef unsigned int PSI_memory_key;
 struct PSI_memory_info_v2
 {

include/mysql/psi/psi_base.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -56,14 +56,21 @@ extern "C" {
 */
 #define PSI_FLAG_STAGE_PROGRESS (1 << 3)
 
-#ifdef HAVE_PSI_INTERFACE
-
 /**
   Shared Exclusive flag.
   Indicates that rwlock support the shared exclusive state.
 */
 #define PSI_RWLOCK_FLAG_SX (1 << 4)
 
+/**
+  Transferable flag.
+  This flag indicate that an instrumented object can
+  be created by a thread and destroyed by another thread.
+*/
+#define PSI_FLAG_TRANSFER (1 << 5)
+
+#ifdef HAVE_PSI_INTERFACE
+
 /**
   @def PSI_VERSION_1
   Performance Schema Interface number for version 1.

include/mysql/psi/psi_memory.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -39,6 +39,8 @@ extern "C" {
 #endif /* DISABLE_ALL_PSI */
 #endif /* HAVE_PSI_INTERFACE */
 
+struct PSI_thread;
+
 /**
   Instrumented memory key.
   To instrument memory, a memory key must be obtained using @c register_memory.
@@ -86,28 +88,41 @@ typedef void (*register_memory_v1_t)
   Instrument memory allocation.
   @param key the memory instrument key
   @param size the size of memory allocated
+  @param[out] owner the memory owner
   @return the effective memory instrument key
 */
 typedef PSI_memory_key (*memory_alloc_v1_t)
-  (PSI_memory_key key, size_t size);
+  (PSI_memory_key key, size_t size, struct PSI_thread ** owner);
 
 /**
   Instrument memory re allocation.
   @param key the memory instrument key
   @param old_size the size of memory previously allocated
   @param new_size the size of memory re allocated
+  @param[in, out] owner the memory owner
   @return the effective memory instrument key
 */
 typedef PSI_memory_key (*memory_realloc_v1_t)
-  (PSI_memory_key key, size_t old_size, size_t new_size);
+  (PSI_memory_key key, size_t old_size, size_t new_size, struct PSI_thread ** owner);
+
+/**
+  Instrument memory claim.
+  @param key the memory instrument key
+  @param size the size of memory allocated
+  @param[in, out] owner the memory owner
+  @return the effective memory instrument key
+*/
+typedef PSI_memory_key (*memory_claim_v1_t)
+  (PSI_memory_key key, size_t size, struct PSI_thread ** owner);
 
 /**
   Instrument memory free.
   @param key the memory instrument key
   @param size the size of memory allocated
+  @param owner the memory owner
 */
 typedef void (*memory_free_v1_t)
-  (PSI_memory_key key, size_t size);
+  (PSI_memory_key key, size_t size, struct PSI_thread * owner);
 
 /** @} (end of group Group_PSI_v1) */
 

include/mysql/service_mysql_alloc.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -32,6 +32,7 @@ typedef int myf_t;
 
 typedef void * (*mysql_malloc_t)(PSI_memory_key key, size_t size, myf_t flags);
 typedef void * (*mysql_realloc_t)(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
+typedef void (*mysql_claim_t)(void *ptr);
 typedef void (*mysql_free_t)(void *ptr);
 typedef void * (*my_memdup_t)(PSI_memory_key key, const void *from, size_t length, myf_t flags);
 typedef char * (*my_strdup_t)(PSI_memory_key key, const char *from, myf_t flags);
@@ -41,6 +42,7 @@ struct mysql_malloc_service_st
 {
   mysql_malloc_t mysql_malloc;
   mysql_realloc_t mysql_realloc;
+  mysql_claim_t mysql_claim;
   mysql_free_t mysql_free;
   my_memdup_t my_memdup;
   my_strdup_t my_strdup;
@@ -53,6 +55,7 @@ extern struct mysql_malloc_service_st *mysql_malloc_service;
 
 #define my_malloc mysql_malloc_service->mysql_malloc
 #define my_realloc mysql_malloc_service->mysql_realloc
+#define my_claim mysql_malloc_service->mysql_claim
 #define my_free mysql_malloc_service->mysql_free
 #define my_memdup mysql_malloc_service->my_memdup
 #define my_strdup mysql_malloc_service->my_strdup
@@ -62,6 +65,7 @@ extern struct mysql_malloc_service_st *mysql_malloc_service;
 
 extern void * my_malloc(PSI_memory_key key, size_t size, myf_t flags);
 extern void * my_realloc(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
+extern void my_claim(void *ptr);
 extern void my_free(void *ptr);
 extern void * my_memdup(PSI_memory_key key, const void *from, size_t length, myf_t flags);
 extern char * my_strdup(PSI_memory_key key, const char *from, myf_t flags);

include/mysql/services.h.pp

@@ -106,10 +106,12 @@
 #include <mysql/service_mysql_alloc.h>
 #include "mysql/psi/psi_memory.h"
 #include "psi_base.h"
+struct PSI_thread;
 typedef unsigned int PSI_memory_key;
 typedef int myf_t;
 typedef void * (*mysql_malloc_t)(PSI_memory_key key, size_t size, myf_t flags);
 typedef void * (*mysql_realloc_t)(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
+typedef void (*mysql_claim_t)(void *ptr);
 typedef void (*mysql_free_t)(void *ptr);
 typedef void * (*my_memdup_t)(PSI_memory_key key, const void *from, size_t length, myf_t flags);
 typedef char * (*my_strdup_t)(PSI_memory_key key, const char *from, myf_t flags);
@@ -118,6 +120,7 @@
 {
   mysql_malloc_t mysql_malloc;
   mysql_realloc_t mysql_realloc;
+  mysql_claim_t mysql_claim;
   mysql_free_t mysql_free;
   my_memdup_t my_memdup;
   my_strdup_t my_strdup;
@@ -126,6 +129,7 @@
 extern struct mysql_malloc_service_st *mysql_malloc_service;
 extern void * my_malloc(PSI_memory_key key, size_t size, myf_t flags);
 extern void * my_realloc(PSI_memory_key key, void *ptr, size_t size, myf_t flags);
+extern void my_claim(void *ptr);
 extern void my_free(void *ptr);
 extern void * my_memdup(PSI_memory_key key, const void *from, size_t length, myf_t flags);
 extern char * my_strdup(PSI_memory_key key, const char *from, myf_t flags);

include/mysql_com.h

@@ -508,6 +508,7 @@ my_bool	my_net_init(NET *net, Vio* vio);
 void my_net_local_init(NET *net);
 void net_end(NET *net);
 void net_clear(NET *net, my_bool check_buffer);
+void net_claim_memory_ownership(NET *net);
 my_bool net_realloc(NET *net, size_t length);
 my_bool	net_flush(NET *net);
 my_bool	my_net_write(NET *net,const unsigned char *packet, size_t len);

include/sql_string.h

@@ -320,6 +320,14 @@ class String
     DBUG_ASSERT(strlen(m_ptr) == m_length);
   }
 
+  void mem_claim()
+  {
+    if (m_is_alloced)
+    {
+      my_claim(m_ptr);
+    }
+  }
+
   void mem_free()
   {
     if (m_is_alloced)
@@ -331,6 +339,7 @@ class String
       m_length= 0;				/* Safety */
     }
   }
+
   bool alloc(size_t arg_length)
   {
     if (arg_length < m_alloced_length)