firebird-mirror/src/utilities/stats.epp

/*
 *	PROGRAM:	JRD Access Method
 *	MODULE:		stats.epp
 *	DESCRIPTION:	Record statistics manager
 *
 * The contents of this file are subject to the Interbase Public
 * License Version 1.0 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy
 * of the License at http://www.Inprise.com/IPL.html
 *
 * Software distributed under the License is distributed on an
 * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code was created by Inprise Corporation
 * and its predecessors. Portions created by Inprise Corporation are
 * Copyright (C) Inprise Corporation.
 *
 * All Rights Reserved.
 * Contributor(s): ______________________________________.
 */

#include "firebird.h"
#include "../jrd/ibase.h"

DATABASE DB = "yachts.lnk";

extern SCHAR *gds__alloc();
extern SLONG gds__vax_integer();

#define ITEM_seq_reads	0
#define ITEM_idx_reads	1
#define ITEM_inserts	2
#define ITEM_updates	3
#define ITEM_deletes	4
#define ITEM_backouts	5
#define ITEM_purges	6
#define ITEM_expunges	7
#define ITEM_count	8

typedef struct stats {
	SSHORT stats_count;
	SSHORT stats_items;			/* Number of item per relation */
	SLONG stats_counts[1];
} *STATS;

static STATS expand_stats();
static int print_line();

static const SCHAR info_request[] = {
	isc_info_read_seq_count,
	isc_info_read_idx_count,
	isc_info_insert_count,
	isc_info_update_count,
	isc_info_delete_count,
	isc_info_backout_count,
	isc_info_purge_count,
	isc_info_expunge_count,
	isc_info_end
};

static const SCHAR* headers[] = {
	"S-Reads",
	"I-Reads",
	"Inserts",
	"Updates",
	"Deletes",
	"Backouts",
	"Purges",
	"Expunges"
};

static int* database_handle;
static int* request_handle;


int stats_analyze(STATS before, STATS after, int(*callback)(), SCHAR *arg)
{
/**************************************
 *
 *	s t a t s _ a n a l y z e
 *
 **************************************
 *
 * Functional description
 *
 **************************************/
	SLONG delta[ITEM_count];

	if (!after)
		return;

	const SLONG* const end = delta + ITEM_count;

	const SLONG* tail2 = 0;
	if (before) {
		tail2 = before->stats_counts;
	}

	SSHORT relation_id = 0
	for (const SLONG* tail = after->stats_counts;
		 relation_id < after->stats_count; ++relation_id)
	{
		SLONG total = 0;
		for (SLONG* p = delta; p < end;) {
			total += *tail;
			*p++ = *tail++;
		}
		if (before && relation_id < before->stats_count)
			for (SLONG* p = delta; p < end;) {
				total -= *tail2;
				*p++ -= *tail2++;
			}
		if (total) {
			(*callback) (arg, relation_id, ITEM_count, headers, delta);
		}
	}
}


int stats_fetch(SLONG *status_vector, int **db_handle, STATS *stats_ptr)
{
/**************************************
 *
 *	s t a t s _ f e t c h
 *
 **************************************
 *
 * Functional description
 *	Gather statistics.
 *
 **************************************/
	SCHAR info_buffer[4096];

	if (isc_database_info(status_vector, db_handle, sizeof(info_request),
						   info_request, sizeof(info_buffer),
						   info_buffer)) 
	{
		return status_vector[1];
	}

	STATS stats = *stats_ptr;
	if (stats)
		zap_longs(stats->stats_counts, stats->stats_count * ITEM_count);
	else
		stats = expand_stats(stats_ptr, 64);

	if (!stats) {
		status_vector[0] = isc_arg_gds;
		status_vector[1] = isc_virmemexh;
		status_vector[2] = isc_arg_end;
		return status_vector[1];
	}
	
	const SCHAR* const end = info_buffer + sizeof(info_buffer);
	for (const SCHAR* p = info_buffer; p < end && *p != isc_info_end;) {
		const SSHORT length = gds__vax_integer(p + 1, 2);
		SSHORT item = -1;
		switch (*p) {
		case isc_info_read_seq_count:
			item = ITEM_seq_reads;
			break;
		case isc_info_read_idx_count:
			item = ITEM_idx_reads;
			break;
		case isc_info_insert_count:
			item = ITEM_inserts;
			break;
		case isc_info_update_count:
			item = ITEM_updates;
			break;
		case isc_info_delete_count:
			item = ITEM_deletes;
			break;
		case isc_info_backout_count:
			item = ITEM_backouts;
			break;
		case isc_info_purge_count:
			item = ITEM_purges;
			break;
		case isc_info_expunge_count:
			item = ITEM_expunges;
			break;
		}
		if (item >= 0) {
			if (get_counts(status_vector, p + 3, length, stats_ptr, item))
				break;
			p += 3 + length;
		}

	} /** MOD I have added this just to compile - it matches the for loop
          but will need to be checkout out before actually being used */

    return status_vector[1];

}


int stats_print(int **db_handle, int **tr_handle, STATS before, STATS after)
{
/**************************************
 *
 *	s t a t s _ p r i n t
 *
 **************************************
 *
 * Functional description
 *
 **************************************/
	if (request_handle && database_handle != *db_handle)
		isc_release_request(gds__status, &request_handle);

	db = database_handle = *db_handle;
	gds__trans = *tr_handle;
	SLONG init = 0;
	stats_analyze(before, after, print_line, &init);
	return 0;
}


static STATS expand_stats(STATS *ptr, SSHORT count)
{
/**************************************
 *
 *	e x p a n d _ s t a t s
 *
 **************************************
 *
 * Functional description
 *	Make sure vector is big enough.
 *
 **************************************/

/* If the thing is already big enough, don't do nothing */
	STATS old = *ptr;
	if (old && old->stats_count < count)
		return old;

	count += 20;
	const SLONG length = sizeof(struct stats) + (ITEM_count * count - 1) * sizeof(SLONG);
	STATS stats = (STATS) gds__alloc(length);
/* FREE: apparently never freed */
	if (!stats)					/* NOMEM: out of memory */
		return NULL;			/* leave *ptr unchanged */
	zap_longs(stats->stats_counts, count * ITEM_count);
	stats->stats_count = count;
	stats->stats_items = ITEM_count;

	if (old) {
		SLONG* p = stats->stats_counts;
		const SLONG* q = old->stats_counts;
		const SLONG* const end = q + ITEM_count * old->stats_count;
		while (q < end) {
			*p++ = *q++;
		}
		gds__free(old);
	}

	return *ptr = stats;
}


static int get_counts(ISC_STATUS *status_vector, SCHAR *info, SSHORT length,
		STATS *stats_ptr, SSHORT item)
{
/**************************************
 *
 *	g e t _ c o u n t s
 *
 **************************************
 *
 * Functional description
 *	Pick up operation counts from information items.
 *
 **************************************/
	STATS stats = *stats_ptr;

	const SCHAR* p = info;
	for (const SCHAR* const end = p + length; p < end; p += 6) {
		const SSHORT relation_id = gds__vax_integer(p, 2);
		if (relation_id >= stats->stats_count) {
			if (!expand_stats(&stats, relation_id)) {
				status_vector[0] = isc_arg_gds;
				status_vector[1] = isc_virmemexh;
				status_vector[2] = isc_arg_end;
				return status_vector[1];
			}
		}
		stats->stats_counts[relation_id * ITEM_count + item] =
			gds__vax_integer(p + 2, 4);
	}
	return status_vector[1];
}


static int print_line(SCHAR *arg, SSHORT relation_id, SSHORT count,
				SCHAR **headers, SLONG *counts)
{
/**************************************
 *
 *	p r i n t _ l i n e
 *
 **************************************
 *
 * Functional description
 *	Display data.
 *
 **************************************/
	if (!*arg) {
		*arg = 1;
		printf("%32s ", " ");
		SSHORT n = count;
		if (n) {
			do {
				printf("%10s", *headers++);
			} while (--n);
		}
		printf("\n");
	}

	// This didn't work previously! GDML uses uppercased keywords.
	FOR (REQUEST_HANDLE request_handle)
		x IN RDB$RELATIONS
		WITH x.RDB$RELATION_ID EQ relation_id
		printf("%32s", x.rdb$relation_name);
		for (const SLONG* const end = counts + count; counts < end; counts++) {
			printf("%10d", *counts);
		}
		printf("\n");
	END_FOR

	return 0;
}


static int zap_longs(SLONG* ptr, SSHORT count)
{
/**************************************
 *
 *	z a p _ l o n g s
 *
 **************************************
 *
 * Functional description
 *	Zero a bunch of SLONGwords.
 *
 **************************************/

	if (count) {
		do {
			*ptr++ = 0;
		} while (--count);
	}
		
	return 0;
}