xref: /titanic_41/usr/src/cmd/tnf/tnfdump/table.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 *	Copyright (c) 1994, by Sun Microsytems, Inc.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdlib.h>
#include <locale.h>

#include "state.h"

/*
 * This file defines routines on a table data structure. There is one
 * static table that has the following operations: insert, sort, print,
 * and get an element by index.
 */

static entry_t	*table_start = NULL;	/* start of table */
static int	table_cur = 0;		/* current size of table */
static int	table_size = 0;		/* max number of elements */

#define	GUESS_NUM_ELEM		(16 * 1024)

static void table_grow		(int);
static int timecompare		(const void *, const void *);

static void
table_grow(int num_entries)
{
	entry_t *temp;

	if (table_start == NULL) {
		table_size = num_entries;
		table_start = malloc(table_size * sizeof (struct entry));
		if (table_start == NULL)
			fail(1, gettext("malloc:"));
		return;
	}
	table_size += num_entries;
	temp = realloc(table_start, table_size * sizeof (struct entry));
	if (temp == NULL)
		fail(1, gettext("realloc:"));
	table_start = temp;
}

static int
timecompare(const void *i, const void *j)
{
	hrtime_t	result;

	result = ((entry_t *)i)->time - ((entry_t *)j)->time;
	if (result < (longlong_t) 0)
		return (-1);
	else if (result == (longlong_t) 0)
		return (0);
	else
		return (1);
}

/*
 * insert an entry into the table.  Automatically grows it if needed
 */
void
table_insert(entry_t *element)
{
	if (table_cur >= table_size) {
		table_grow(GUESS_NUM_ELEM);
	}
	/* copy the structure to the array, increment cur index */
	table_start[table_cur++] = *element;
}

int
table_get_num_elements(void)
{
	return (table_size);
}

void
table_sort(void)
{
	qsort(table_start, table_cur, sizeof (struct entry), &timecompare);
}

void
table_print(void (*print_elem)(entry_t *))
{
	int i;

	for (i = 0; i < table_cur; i++) {
		print_elem(&(table_start[i]));
	}
}

entry_t *
table_get_entry_indexed(int n)
{
	if (n < table_cur)
		return (&(table_start[n]));
	return (NULL);
}