Merge sanja.is.com.ua:/home/bell/mysql/bk/mysql-4.0 (5f673773) · Commits · Software / OSDI20 Artifacts / mariadb

sql/mysql_priv.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -318,6 +318,7 @@ inline THD *_current_thd(void)
		#define query_cache_store_query(A, B) query_cache.store_query(A, B)
		#define query_cache_destroy() query_cache.destroy()
		#define query_cache_result_size_limit(A) query_cache.result_size_limit(A)
		#define query_cache_init() query_cache.init()
		#define query_cache_resize(A) query_cache.resize(A)
		#define query_cache_invalidate3(A, B, C) query_cache.invalidate(A, B, C)
		#define query_cache_invalidate1(A) query_cache.invalidate(A)
		@@ -329,6 +330,7 @@ inline THD *_current_thd(void)
		#define query_cache_store_query(A, B)
		#define query_cache_destroy()
		#define query_cache_result_size_limit(A)
		#define query_cache_init()
		#define query_cache_resize(A)
		#define query_cache_invalidate3(A, B, C)
		#define query_cache_invalidate1(A)

sql/mysqld.cc

+1 −0

Original line number	Diff line number	Diff line
		@@ -2461,6 +2461,7 @@ You should consider changing lower_case_table_names to 1 or 2",
		unireg_abort(1);
		}
		query_cache_result_size_limit(query_cache_limit);
		query_cache_init();
		query_cache_resize(query_cache_size);
		randominit(&sql_rand,(ulong) start_time,(ulong) start_time/2);
		reset_floating_point_exceptions();

sql/sql_cache.cc

+80 −34

Original line number	Diff line number	Diff line
		@@ -563,13 +563,18 @@ void query_cache_insert(NET net, const char packet, ulong length)
		{
		DBUG_ENTER("query_cache_insert");

		#ifndef DBUG_OFF
		// Check if we have called query_cache.wreck() (which disables the cache)
		if (query_cache.query_cache_size == 0)
		STRUCT_LOCK(&query_cache.structure_guard_mutex);
		/*
		It is very unlikely that following condition is TRUE (it is possible
		only if other thread is resizing cache), so we check it only after guard
		mutex lock
		*/
		if (unlikely(query_cache.query_cache_size == 0))
		{
		STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
		DBUG_VOID_RETURN;
		#endif
		}

		STRUCT_LOCK(&query_cache.structure_guard_mutex);
		Query_cache_block query_block = ((Query_cache_block)
		net->query_cache_query);
		if (query_block)
		@@ -612,14 +617,20 @@ void query_cache_abort(NET *net)
		{
		DBUG_ENTER("query_cache_abort");

		#ifndef DBUG_OFF
		// Check if we have called query_cache.wreck() (which disables the cache)
		if (query_cache.query_cache_size == 0)
		DBUG_VOID_RETURN;
		#endif
		if (net->query_cache_query != 0) // Quick check on unlocked structure
		{
		STRUCT_LOCK(&query_cache.structure_guard_mutex);
		/*
		It is very unlikely that following condition is TRUE (it is possible
		only if other thread is resizing cache), so we check it only after guard
		mutex lock
		*/
		if (unlikely(query_cache.query_cache_size == 0))
		{
		STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
		DBUG_VOID_RETURN;
		}

		Query_cache_block query_block = ((Query_cache_block)
		net->query_cache_query);
		if (query_block) // Test if changed by other thread
		@@ -641,14 +652,20 @@ void query_cache_end_of_result(NET *net)
		{
		DBUG_ENTER("query_cache_end_of_result");

		#ifndef DBUG_OFF
		// Check if we have called query_cache.wreck() (which disables the cache)
		if (query_cache.query_cache_size == 0) DBUG_VOID_RETURN;
		#endif

		if (net->query_cache_query != 0) // Quick check on unlocked structure
		{
		STRUCT_LOCK(&query_cache.structure_guard_mutex);
		/*
		It is very unlikely that following condition is TRUE (it is possible
		only if other thread is resizing cache), so we check it only after guard
		mutex lock
		*/
		if (unlikely(query_cache.query_cache_size == 0))
		{
		STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
		DBUG_VOID_RETURN;
		}

		Query_cache_block query_block = ((Query_cache_block)
		net->query_cache_query);
		if (query_block)
		@@ -728,9 +745,14 @@ ulong Query_cache::resize(ulong query_cache_size_arg)
		DBUG_ENTER("Query_cache::resize");
		DBUG_PRINT("qcache", ("from %lu to %lu",query_cache_size,
		query_cache_size_arg));
		free_cache(0);
		DBUG_ASSERT(initialized);
		STRUCT_LOCK(&structure_guard_mutex);
		if (query_cache_size > 0)
		free_cache();
		query_cache_size= query_cache_size_arg;
		DBUG_RETURN(::query_cache_size= init_cache());
		::query_cache_size= init_cache();
		STRUCT_UNLOCK(&structure_guard_mutex);
		DBUG_RETURN(::query_cache_size);
		}


		@@ -1307,7 +1329,7 @@ void Query_cache::destroy()
		}
		else
		{
		free_cache(1);
		free_cache();
		pthread_mutex_destroy(&structure_guard_mutex);
		initialized = 0;
		}
		@@ -1336,8 +1358,6 @@ ulong Query_cache::init_cache()
		int align;

		DBUG_ENTER("Query_cache::init_cache");
		if (!initialized)
		init();
		approx_additional_data_size = (sizeof(Query_cache) +
		sizeof(gptr)*(def_query_hash_size+
		def_table_hash_size));
		@@ -1395,14 +1415,9 @@ ulong Query_cache::init_cache()
		goto err;
		query_cache_size -= additional_data_size;

		STRUCT_LOCK(&structure_guard_mutex);

		if (!(cache= (byte *)
		my_malloc_lock(query_cache_size+additional_data_size, MYF(0))))
		{
		STRUCT_UNLOCK(&structure_guard_mutex);
		goto err;
		}

		DBUG_PRINT("qcache", ("cache length %lu, min unit %lu, %u bins",
		query_cache_size, min_allocation_unit, mem_bin_num));
		@@ -1482,7 +1497,6 @@ ulong Query_cache::init_cache()

		queries_in_cache = 0;
		queries_blocks = 0;
		STRUCT_UNLOCK(&structure_guard_mutex);
		DBUG_RETURN(query_cache_size +
		additional_data_size + approx_additional_data_size);

		@@ -1498,6 +1512,7 @@ void Query_cache::make_disabled()
		{
		DBUG_ENTER("Query_cache::make_disabled");
		query_cache_size= 0;
		queries_blocks= 0;
		free_memory= 0;
		bins= 0;
		steps= 0;
		@@ -1509,14 +1524,11 @@ void Query_cache::make_disabled()
		}


		void Query_cache::free_cache(my_bool destruction)
		void Query_cache::free_cache()
		{
		DBUG_ENTER("Query_cache::free_cache");
		if (query_cache_size > 0)
		{
		if (!destruction)
		STRUCT_LOCK(&structure_guard_mutex);

		flush_cache();
		#ifndef DBUG_OFF
		if (bins[0].free_blocks == 0)
		@@ -1538,8 +1550,6 @@ void Query_cache::free_cache(my_bool destruction)
		make_disabled();
		hash_free(&queries);
		hash_free(&tables);
		if (!destruction)
		STRUCT_UNLOCK(&structure_guard_mutex);
		}
		DBUG_VOID_RETURN;
		}
		@@ -2149,7 +2159,19 @@ Query_cache::allocate_block(ulong len, my_bool not_less, ulong min,
		}

		if (!under_guard)
		{
		STRUCT_LOCK(&structure_guard_mutex);
		/*
		It is very unlikely that following condition is TRUE (it is possible
		only if other thread is resizing cache), so we check it only after
		guard mutex lock
		*/
		if (unlikely(query_cache.query_cache_size == 0))
		{
		STRUCT_UNLOCK(&structure_guard_mutex);
		DBUG_RETURN(0);
		}
		}

		/* Free old queries until we have enough memory to store this block */
		Query_cache_block *block;
		@@ -2606,6 +2628,17 @@ void Query_cache::pack_cache()
		{
		DBUG_ENTER("Query_cache::pack_cache");
		STRUCT_LOCK(&structure_guard_mutex);
		/*
		It is very unlikely that following condition is TRUE (it is possible
		only if other thread is resizing cache), so we check it only after
		guard mutex lock
		*/
		if (unlikely(query_cache_size == 0))
		{
		STRUCT_UNLOCK(&structure_guard_mutex);
		DBUG_VOID_RETURN;
		}

		DBUG_EXECUTE("check_querycache",query_cache.check_integrity(1););

		byte *border = 0;
		@@ -2915,6 +2948,7 @@ my_bool Query_cache::join_results(ulong join_limit)
		STRUCT_LOCK(&structure_guard_mutex);
		if (queries_blocks != 0)
		{
		DBUG_ASSERT(query_cache_size > 0);
		Query_cache_block *block = queries_blocks;
		do
		{
		@@ -3209,7 +3243,19 @@ my_bool Query_cache::check_integrity(bool not_locked)
		DBUG_RETURN(0);
		}
		if (!not_locked)
		{
		STRUCT_LOCK(&structure_guard_mutex);
		/*
		It is very unlikely that following condition is TRUE (it is possible
		only if other thread is resizing cache), so we check it only after
		guard mutex lock
		*/
		if (unlikely(query_cache_size == 0))
		{
		STRUCT_UNLOCK(&query_cache.structure_guard_mutex);
		DBUG_RETURN(0);
		}
		}

		if (hash_check(&queries))
		{

sql/sql_cache.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -310,10 +310,9 @@ class Query_cache
		Following function control structure_guard_mutex
		by themself or don't need structure_guard_mutex
		*/
		void init();
		ulong init_cache();
		void make_disabled();
		void free_cache(my_bool destruction);
		void free_cache();
		Query_cache_block *write_block_data(ulong data_len, gptr data,
		ulong header_len,
		Query_cache_block::block_type type,
		@@ -346,6 +345,8 @@ class Query_cache
		uint def_query_hash_size = QUERY_CACHE_DEF_QUERY_HASH_SIZE,
		uint def_table_hash_size = QUERY_CACHE_DEF_TABLE_HASH_SIZE);

		/* initialize cache (mutex) */
		void init();
		/* resize query cache (return real query size, 0 if disabled) */
		ulong resize(ulong query_cache_size);
		inline void result_size_limit(ulong limit){query_cache_limit=limit;}