~drizzle-trunk/drizzle/development : contents of plugin/logging_stats/cumulative

~drizzle-trunk/drizzle/development : (revision 2370.1.1)

/*
 * Copyright (C) 2010 Joseph Daly <skinny.moey@gmail.com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *   * Neither the name of Joseph Daly nor the names of its contributors
 *     may be used to endorse or promote products derived from this software
 *     without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <config.h>
#include <drizzled/statistics_variables.h>
#include "cumulative_stats.h"

using namespace std;
using namespace drizzled;

CumulativeStats::CumulativeStats(uint32_t in_cumulative_stats_by_user_max) 
    :
      cumulative_stats_by_user_max(in_cumulative_stats_by_user_max)  
{
  cumulative_stats_by_user_vector= new vector<ScoreboardSlot *>(cumulative_stats_by_user_max);

  vector<ScoreboardSlot *>::iterator it= cumulative_stats_by_user_vector->begin();
  for (int32_t j=0; j < cumulative_stats_by_user_max; ++j)
  {
    ScoreboardSlot *scoreboard_slot= new ScoreboardSlot();
    it= cumulative_stats_by_user_vector->insert(it, scoreboard_slot);
  }
  cumulative_stats_by_user_vector->resize(cumulative_stats_by_user_max);

  last_valid_index= INVALID_INDEX;
  isOpenUserSlots= true;
  global_stats= new GlobalStats();
  global_status_vars= new StatusVars();

  /* calculate the approximate memory allocation for the cumulative statistics */
  size_t statusVarsSize= sizeof(StatusVars) + sizeof(system_status_var);
  size_t userCommandsSize= sizeof(UserCommands) + sizeof(uint64_t) * SQLCOM_END;

  cumulative_size_bytes= (statusVarsSize + userCommandsSize) * cumulative_stats_by_user_max; 
}

CumulativeStats::~CumulativeStats()
{
  vector<ScoreboardSlot *>::iterator it= cumulative_stats_by_user_vector->begin();
  for (; it < cumulative_stats_by_user_vector->end(); ++it)
  {
    delete *it;
  }
  cumulative_stats_by_user_vector->clear();
  delete cumulative_stats_by_user_vector;
  delete global_stats;
  delete global_status_vars;
}

void CumulativeStats::logUserStats(ScoreboardSlot *scoreboard_slot, bool reserveSlot)
{
  vector<ScoreboardSlot *>::iterator cumulative_it= cumulative_stats_by_user_vector->begin();

  /* Search if this is a pre-existing user */

  int32_t current_index= last_valid_index;

  if (cumulative_stats_by_user_max <= current_index)
  {
    current_index= cumulative_stats_by_user_max;
  }

  for (int32_t j=0; j <= current_index; ++j)
  {
    ScoreboardSlot *cumulative_scoreboard_slot= *cumulative_it;
    string user= cumulative_scoreboard_slot->getUser();
    if (user.compare(scoreboard_slot->getUser()) == 0)
    {
      reserveSlot= false;
      cumulative_scoreboard_slot->merge(scoreboard_slot);
      break;
    }
    ++cumulative_it;
  }
  
  if (reserveSlot)
  {
    /* the user was not found */
    /* its possible multiple simultaneous connections with the same user
       could result in duplicate entries here, not likely and it would
       be harmless except for duplicate users showing up in a query */
    
    if (hasOpenUserSlots())
    { 
      int32_t our_index= last_valid_index.add_and_fetch(1);
      if (our_index < cumulative_stats_by_user_max)
      {
        ScoreboardSlot *cumulative_scoreboard_slot=
          cumulative_stats_by_user_vector->at(our_index);
        cumulative_scoreboard_slot->setUser(scoreboard_slot->getUser());
        cumulative_scoreboard_slot->merge(scoreboard_slot);
        cumulative_scoreboard_slot->setInUse(true);
      } 
      else 
      {
        last_valid_index= cumulative_stats_by_user_max - 1; 
        isOpenUserSlots= false;
      }
    } 
  }
}

void CumulativeStats::logGlobalStats(ScoreboardSlot* scoreboard_slot)
{
  global_stats->updateUserCommands(scoreboard_slot); 
}

void CumulativeStats::logGlobalStatusVars(ScoreboardSlot* scoreboard_slot)
{
  global_status_vars->merge(scoreboard_slot->getStatusVars());
}

int32_t CumulativeStats::getCumulativeStatsLastValidIndex()
{
  if (last_valid_index < cumulative_stats_by_user_max)
  {
    return last_valid_index;
  } 
  else 
  {
    return cumulative_stats_by_user_max;
  }
}

void CumulativeStats::sumCurrentScoreboard(Scoreboard *scoreboard,
                                           StatusVars *current_status_vars,
                                           UserCommands *current_user_commands)
{
  /* the vector of vectors */
  vector<vector<ScoreboardSlot* >* > *vector_of_scoreboard_vectors= 
    scoreboard->getVectorOfScoreboardVectors();

  /* iterate through each vector from above and sum each ScoreboardSlot */

  vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_begin_it= vector_of_scoreboard_vectors->begin(); 

  vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_end_it= vector_of_scoreboard_vectors->end(); 

  for (; v_of_scoreboard_v_begin_it != v_of_scoreboard_v_end_it; ++v_of_scoreboard_v_begin_it)
  {
    vector<ScoreboardSlot* > *scoreboard_vector= *v_of_scoreboard_v_begin_it;
    
    vector<ScoreboardSlot* >::iterator scoreboard_vector_it= scoreboard_vector->begin();
    vector<ScoreboardSlot* >::iterator scoreboard_vector_end= scoreboard_vector->end();
    for (; scoreboard_vector_it != scoreboard_vector_end; ++scoreboard_vector_it)
    {
      ScoreboardSlot *scoreboard_slot= *scoreboard_vector_it;
      if (scoreboard_slot->isInUse())
      {
        if (current_status_vars)
        {
          current_status_vars->merge(scoreboard_slot->getStatusVars());
        }

        if (current_user_commands)
        {
          current_user_commands->merge(scoreboard_slot->getUserCommands());
        }
      }
    }
  }
}

1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	1	/*
1999.6.1 by kalebral at gmail update Copyright strings to a more common format to help with creating the master debian copyright file	2	* Copyright (C) 2010 Joseph Daly <skinny.moey@gmail.com>
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions are met:
	7	*
	8	* * Redistributions of source code must retain the above copyright notice,
	9	* this list of conditions and the following disclaimer.
	10	* * Redistributions in binary form must reproduce the above copyright notice,
	11	* this list of conditions and the following disclaimer in the documentation
	12	* and/or other materials provided with the distribution.
	13	* * Neither the name of Joseph Daly nor the names of its contributors
	14	* may be used to endorse or promote products derived from this software
	15	* without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	18	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	20	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
	21	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	22	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	23	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	24	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	25	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	26	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	27	* THE POSSIBILITY OF SUCH DAMAGE.
	28	*/
	29
2173.2.1 by Monty Taylor Fixes incorrect usage of include	30	#include <config.h>
2241.3.1 by Olaf van der Spek Refactor Session::status_var	31	#include <drizzled/statistics_variables.h>
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	32	#include "cumulative_stats.h"
	33
	34	using namespace std;
1711.7.2 by Joseph Daly add memory usage	35	using namespace drizzled;
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	36
	37	CumulativeStats::CumulativeStats(uint32_t in_cumulative_stats_by_user_max)
	38	:
	39	cumulative_stats_by_user_max(in_cumulative_stats_by_user_max)
	40	{
	41	cumulative_stats_by_user_vector= new vector<ScoreboardSlot *>(cumulative_stats_by_user_max);
	42
	43	vector<ScoreboardSlot *>::iterator it= cumulative_stats_by_user_vector->begin();
1491.4.2 by Joe Daly rework atomics on cumulative user tables	44	for (int32_t j=0; j < cumulative_stats_by_user_max; ++j)
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	45	{
	46	ScoreboardSlot *scoreboard_slot= new ScoreboardSlot();
	47	it= cumulative_stats_by_user_vector->insert(it, scoreboard_slot);
	48	}
	49	cumulative_stats_by_user_vector->resize(cumulative_stats_by_user_max);
	50
1491.4.2 by Joe Daly rework atomics on cumulative user tables	51	last_valid_index= INVALID_INDEX;
1491.4.4 by Joe Daly rework UserCommands class to have a simplier interface and remove get/increment functions	52	isOpenUserSlots= true;
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	53	global_stats= new GlobalStats();
1561.3.4 by Joe Daly global status changes, will need updates to combine session and global status to a realistic class structure	54	global_status_vars= new StatusVars();
1711.7.2 by Joseph Daly add memory usage	55
	56	/* calculate the approximate memory allocation for the cumulative statistics */
	57	size_t statusVarsSize= sizeof(StatusVars) + sizeof(system_status_var);
	58	size_t userCommandsSize= sizeof(UserCommands) + sizeof(uint64_t) * SQLCOM_END;
	59
	60	cumulative_size_bytes= (statusVarsSize + userCommandsSize) * cumulative_stats_by_user_max;
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	61	}
	62
	63	CumulativeStats::~CumulativeStats()
	64	{
	65	vector<ScoreboardSlot *>::iterator it= cumulative_stats_by_user_vector->begin();
	66	for (; it < cumulative_stats_by_user_vector->end(); ++it)
	67	{
	68	delete *it;
	69	}
	70	cumulative_stats_by_user_vector->clear();
	71	delete cumulative_stats_by_user_vector;
	72	delete global_stats;
1561.3.4 by Joe Daly global status changes, will need updates to combine session and global status to a realistic class structure	73	delete global_status_vars;
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	74	}
	75
1625.2.1 by Joe Daly initial user stats impl	76	void CumulativeStats::logUserStats(ScoreboardSlot *scoreboard_slot, bool reserveSlot)
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	77	{
	78	vector<ScoreboardSlot *>::iterator cumulative_it= cumulative_stats_by_user_vector->begin();
	79
	80	/* Search if this is a pre-existing user */
	81
1491.4.2 by Joe Daly rework atomics on cumulative user tables	82	int32_t current_index= last_valid_index;
	83
	84	if (cumulative_stats_by_user_max <= current_index)
	85	{
	86	current_index= cumulative_stats_by_user_max;
	87	}
	88
	89	for (int32_t j=0; j <= current_index; ++j)
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	90	{
	91	ScoreboardSlot cumulative_scoreboard_slot= cumulative_it;
	92	string user= cumulative_scoreboard_slot->getUser();
	93	if (user.compare(scoreboard_slot->getUser()) == 0)
	94	{
1625.2.1 by Joe Daly initial user stats impl	95	reserveSlot= false;
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	96	cumulative_scoreboard_slot->merge(scoreboard_slot);
	97	break;
	98	}
	99	++cumulative_it;
	100	}
1625.2.1 by Joe Daly initial user stats impl	101
1625.2.1 by Joe Daly initial user stats impl	102	if (reserveSlot)
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	103	{
	104	/* the user was not found */
	105	/* its possible multiple simultaneous connections with the same user
	106	could result in duplicate entries here, not likely and it would
	107	be harmless except for duplicate users showing up in a query */
	108
	109	if (hasOpenUserSlots())
	110	{
1491.4.2 by Joe Daly rework atomics on cumulative user tables	111	int32_t our_index= last_valid_index.add_and_fetch(1);
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	112	if (our_index < cumulative_stats_by_user_max)
	113	{
	114	ScoreboardSlot *cumulative_scoreboard_slot=
	115	cumulative_stats_by_user_vector->at(our_index);
	116	cumulative_scoreboard_slot->setUser(scoreboard_slot->getUser());
	117	cumulative_scoreboard_slot->merge(scoreboard_slot);
1491.4.2 by Joe Daly rework atomics on cumulative user tables	118	cumulative_scoreboard_slot->setInUse(true);
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	119	}
	120	else
	121	{
1491.4.2 by Joe Daly rework atomics on cumulative user tables	122	last_valid_index= cumulative_stats_by_user_max - 1;
1491.4.4 by Joe Daly rework UserCommands class to have a simplier interface and remove get/increment functions	123	isOpenUserSlots= false;
1491.4.1 by Joe Daly move any tracking logic out of logging_stats its almost just a entry point, rework logic on cumulative stats by user to use a atomic rather then a lock	124	}
	125	}
	126	}
	127	}
	128
	129	void CumulativeStats::logGlobalStats(ScoreboardSlot* scoreboard_slot)
	130	{
	131	global_stats->updateUserCommands(scoreboard_slot);
	132	}
1491.4.2 by Joe Daly rework atomics on cumulative user tables	133
1561.3.4 by Joe Daly global status changes, will need updates to combine session and global status to a realistic class structure	134	void CumulativeStats::logGlobalStatusVars(ScoreboardSlot* scoreboard_slot)
	135	{
	136	global_status_vars->merge(scoreboard_slot->getStatusVars());
	137	}
	138
	139	int32_t CumulativeStats::getCumulativeStatsLastValidIndex()
1491.4.2 by Joe Daly rework atomics on cumulative user tables	140	{
	141	if (last_valid_index < cumulative_stats_by_user_max)
	142	{
	143	return last_valid_index;
	144	}
	145	else
	146	{
	147	return cumulative_stats_by_user_max;
	148	}
	149	}
1561.3.4 by Joe Daly global status changes, will need updates to combine session and global status to a realistic class structure	150
1616.2.1 by Joe Daly update GLOBAL_STATEMENTS logic it was not including a sum of the current scoreboard only sessions that had terminated	151	void CumulativeStats::sumCurrentScoreboard(Scoreboard *scoreboard,
	152	StatusVars *current_status_vars,
	153	UserCommands *current_user_commands)
1561.3.4 by Joe Daly global status changes, will need updates to combine session and global status to a realistic class structure	154	{
	155	/* the vector of vectors */
	156	vector<vector<ScoreboardSlot* >* > *vector_of_scoreboard_vectors=
	157	scoreboard->getVectorOfScoreboardVectors();
	158
	159	/* iterate through each vector from above and sum each ScoreboardSlot */
	160
	161	vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_begin_it= vector_of_scoreboard_vectors->begin();
	162
	163	vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_end_it= vector_of_scoreboard_vectors->end();
	164
	165	for (; v_of_scoreboard_v_begin_it != v_of_scoreboard_v_end_it; ++v_of_scoreboard_v_begin_it)
	166	{
	167	vector<ScoreboardSlot* > scoreboard_vector= v_of_scoreboard_v_begin_it;
	168
	169	vector<ScoreboardSlot* >::iterator scoreboard_vector_it= scoreboard_vector->begin();
	170	vector<ScoreboardSlot* >::iterator scoreboard_vector_end= scoreboard_vector->end();
	171	for (; scoreboard_vector_it != scoreboard_vector_end; ++scoreboard_vector_it)
	172	{
	173	ScoreboardSlot scoreboard_slot= scoreboard_vector_it;
	174	if (scoreboard_slot->isInUse())
	175	{
1616.2.1 by Joe Daly update GLOBAL_STATEMENTS logic it was not including a sum of the current scoreboard only sessions that had terminated	176	if (current_status_vars)
	177	{
	178	current_status_vars->merge(scoreboard_slot->getStatusVars());
	179	}
	180
	181	if (current_user_commands)
	182	{
	183	current_user_commands->merge(scoreboard_slot->getUserCommands());
	184	}
1561.3.4 by Joe Daly global status changes, will need updates to combine session and global status to a realistic class structure	185	}
	186	}
	187	}
	188	}