amiga-clib2/library/stdlib_get_slab_stats.c

/*
 * :ts=4
 *
 * Portable ISO 'C' (1994) runtime library for the Amiga computer
 * Copyright (c) 2002-2015 by Olaf Barthel <obarthel (at) gmx.net>
 * 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.
 *
 *   - Neither the name of Olaf Barthel nor the names of 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 OWNER 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.
 */

#ifndef _STDLIB_HEADERS_H
#include "stdlib_headers.h"
#endif /* _STDLIB_HEADERS_H */

/****************************************************************************/

#ifndef _STDLIB_MEMORY_H
#include "stdlib_memory.h"
#endif /* _STDLIB_MEMORY_H */

/****************************************************************************/

struct context
{
	int						status;
	void *					user_data;
	__slab_status_callback	callback;
	char *					buffer;
	size_t					buffer_size;
};

/****************************************************************************/

static void print(struct context * ct, const char * format, ...)
{
	if(ct->status == 0)
	{
		va_list args;
		int len;

		va_start(args,format);
		len = vsnprintf(ct->buffer, ct->buffer_size, format, args);
		va_end(args);

		/* This shouldn't happen: the buffer ought to be large enough
		 * to hold every single line.
		 */
		if(len >= (int)ct->buffer_size)
			len = strlen(ct->buffer);

		ct->status = (*ct->callback)(ct->user_data, ct->buffer, len);
	}
}

/****************************************************************************/

void
__get_slab_stats(void * user_data, __slab_status_callback callback)
{
	if(__slab_data.sd_InUse)
	{
		static int times_checked = 1;

		const struct SlabNode * sn;
		size_t num_empty_slabs = 0;
		size_t num_full_slabs = 0;
		size_t num_slabs = 0;
		size_t slab_allocation_size = 0;
		size_t total_slab_allocation_size = 0;
		struct context ct;
		char line[1024];
		char time_buffer[40];
		time_t now;
		struct tm when;
		int i;

 		memset(&ct, 0, sizeof(ct));

		ct.user_data	= user_data;
		ct.callback		= callback;
		ct.buffer		= line;
		ct.buffer_size	= sizeof(line);

		__memory_lock();

		now = time(NULL);
		localtime_r(&now, &when);

		strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%dT%H:%M:%S", &when);

		print(&ct,"{\n");

		print(&ct,"\t\"when\": \"%s\",\n", time_buffer);
		print(&ct,"\t\"times_checked\": %d,\n", times_checked++);
		print(&ct,"\t\"slab_size\": %zu,\n", __slab_data.sd_StandardSlabSize);
		print(&ct,"\t\"num_single_allocations\": %zu,\n", __slab_data.sd_NumSingleAllocations);
		print(&ct,"\t\"total_single_allocation_size\": %zu,\n", __slab_data.sd_TotalSingleAllocationSize);

		if(__slab_data.sd_SingleAllocations.mlh_Head->mln_Succ != NULL)
		{
			const struct SlabSingleAllocation * ssa;

			print(&ct,"\t\"single_allocations\": [\n");

			for(ssa = (struct SlabSingleAllocation *)__slab_data.sd_SingleAllocations.mlh_Head ;
			    ssa->ssa_MinNode.mln_Succ != NULL && ct.status == 0 ;
			    ssa = (struct SlabSingleAllocation *)ssa->ssa_MinNode.mln_Succ)
			{
				print(&ct,"\t\t{ \"size\": %lu, \"total_size\": %lu }%s\n",
					ssa->ssa_Size - sizeof(*ssa), ssa->ssa_Size,
					ssa->ssa_MinNode.mln_Succ->mln_Succ != NULL ? "," : "");
			}

			print(&ct,"\t],\n");
		}
		else
		{
			print(&ct,"\t\"single_allocations\": [],\n");
		}

		for(i = 0 ; i < (int)NUM_ENTRIES(__slab_data.sd_Slabs) ; i++)
		{
			for(sn = (struct SlabNode *)__slab_data.sd_Slabs[i].mlh_Head ;
			    sn->sn_MinNode.mln_Succ != NULL ;
			    sn = (struct SlabNode *)sn->sn_MinNode.mln_Succ)
			{
				if (sn->sn_UseCount == 0)
					num_empty_slabs++;
				else if (sn->sn_UseCount == sn->sn_Count)
					num_full_slabs++;

				num_slabs++;

				slab_allocation_size += sn->sn_ChunkSize * sn->sn_UseCount;
				total_slab_allocation_size += sizeof(*sn) + __slab_data.sd_StandardSlabSize;
			}
		}

		print(&ct,"\t\"num_slabs\": %zu,\n", num_slabs);
		print(&ct,"\t\"num_empty_slabs\": %zu,\n", num_empty_slabs);
		print(&ct,"\t\"num_full_slabs\": %zu,\n", num_full_slabs);
		print(&ct,"\t\"slab_allocation_size\": %zu,\n", slab_allocation_size);
		print(&ct,"\t\"total_slab_allocation_size\": %zu,\n", total_slab_allocation_size);

		if(num_slabs > 0)
		{
			const char * eol = "";

			print(&ct,"\t\"slabs\": [\n");

			for(i = 0 ; i < (int)NUM_ENTRIES(__slab_data.sd_Slabs) && ct.status == 0 ; i++)
			{
				for(sn = (struct SlabNode *)__slab_data.sd_Slabs[i].mlh_Head ;
				    sn->sn_MinNode.mln_Succ != NULL && ct.status == 0 ;
				    sn = (struct SlabNode *)sn->sn_MinNode.mln_Succ)
				{
					print(&ct,"%s\t\t{ \"size\": %lu, \"chunks\": %lu, \"chunks_in_use\": %lu, \"times_reused\": %lu }",
						eol,
						sn->sn_ChunkSize,
						sn->sn_Count,
						sn->sn_UseCount,
						sn->sn_NumReused);

					eol = ",\n";
				}
			}

			print(&ct,"\n\t]\n");
		}
		else
		{
			print(&ct,"\t\"slabs\": []\n");
		}

		print(&ct,"}\n");

		__memory_unlock();
	}
}