/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#include "rtl/alloc.h"
#include "alloc_impl.h"

#ifndef INCLUDED_STRING_H
#include <string.h>
#define INCLUDED_STRING_H
#endif

#if !defined(FORCE_SYSALLOC)

/* ================================================================= *
 *
 * custom allocator includes.
 *
 * ================================================================= */

#ifndef INCLUDED_STDIO_H
#include <stdio.h>
#define INCLUDED_STDIO_H
#endif
#include "internal/once.h"
#include "sal/macros.h"
#include "osl/diagnose.h"

/* ================================================================= *
 *
 * custom allocator internals.
 *
 * ================================================================= */

static const sal_Size g_alloc_sizes[] =
{
	/* powers of 2**(1/4) */
	4 *    4,           6 *    4,
	4 *    8, 5 *    8, 6 *    8, 7 *    8,
	4 *   16, 5 *   16, 6 *   16, 7 *   16,
	4 *   32, 5 *   32, 6 *   32, 7 *   32,
	4 *   64, 5 *   64, 6 *   64, 7 *   64,
	4 *  128, 5 *  128, 6 *  128, 7 *  128,
	4 *  256, 5 *  256, 6 *  256, 7 *  256,
	4 *  512, 5 *  512, 6 *  512, 7 *  512,
	4 * 1024, 5 * 1024, 6 * 1024, 7 * 1024,
	4 * 2048, 5 * 2048, 6 * 2048, 7 * 2048,
	4 * 4096
};

#define RTL_MEMORY_CACHED_LIMIT 4 * 4096
#define RTL_MEMORY_CACHED_SIZES (sizeof(g_alloc_sizes) / sizeof(g_alloc_sizes[0]))

static rtl_cache_type * g_alloc_caches[RTL_MEMORY_CACHED_SIZES] =
{
	0,
};

#ifdef NEED_ALIGN16
#define RTL_MEMALIGN       16
#define RTL_MEMALIGN_SHIFT 4
#else
#define RTL_MEMALIGN       8
#define RTL_MEMALIGN_SHIFT 3
#endif

static rtl_cache_type * g_alloc_table[RTL_MEMORY_CACHED_LIMIT >> RTL_MEMALIGN_SHIFT] =
{
	0,
};

static rtl_arena_type * gp_alloc_arena = NULL;

/* ================================================================= *
 *
 * custom allocator initialization / finalization.
 *
 * ================================================================= */

static void
rtl_memory_once_init (void)
{
	{
		/* global memory arena */
		OSL_ASSERT(gp_alloc_arena == NULL);

		gp_alloc_arena = rtl_arena_create (
			"rtl_alloc_arena",
			2048,     /* quantum */
			0,        /* w/o quantum caching */
			0,        /* default source */
			rtl_arena_alloc,
			rtl_arena_free,
			0         /* flags */
		);
		OSL_ASSERT(gp_alloc_arena != NULL);
	}
	{
		sal_Size size;
		int i, n = RTL_MEMORY_CACHED_SIZES;

		for (i = 0; i < n; i++)
		{
			char name[RTL_CACHE_NAME_LENGTH + 1];
			(void) snprintf (name, sizeof(name), "rtl_alloc_%lu", g_alloc_sizes[i]);
			g_alloc_caches[i] = rtl_cache_create (name, g_alloc_sizes[i], 0, NULL, NULL, NULL, NULL, NULL, 0);
		}

		size = RTL_MEMALIGN;
		for (i = 0; i < n; i++)
		{
			while (size <= g_alloc_sizes[i])
			{
				g_alloc_table[(size - 1) >> RTL_MEMALIGN_SHIFT] = g_alloc_caches[i];
				size += RTL_MEMALIGN;
			}
		}
	}
}

static int
rtl_memory_init (void)
{
	static sal_once_type g_once = SAL_ONCE_INIT;
	SAL_ONCE(&g_once, rtl_memory_once_init);
	return (gp_alloc_arena != NULL);
}

/* ================================================================= */

/*
  Issue http://udk.openoffice.org/issues/show_bug.cgi?id=92388

  Mac OS X does not seem to support "__cxa__atexit", thus leading
  to the situation that "__attribute__((destructor))__" functions
  (in particular "rtl_{memory|cache|arena}_fini") become called
  _before_ global C++ object d'tors.

  Delegated the call to "rtl_memory_fini()" into a dummy C++ object,
  see alloc_fini.cxx .
*/
#if defined(__GNUC__) && !defined(MACOSX)
static void rtl_memory_fini (void) __attribute__((destructor));
#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
#pragma fini(rtl_memory_fini)
static void rtl_memory_fini (void);
#endif /* __GNUC__ || __SUNPRO_C */

void
rtl_memory_fini (void)
{
	int i, n;

	/* clear g_alloc_table */
	memset (g_alloc_table, 0, sizeof(g_alloc_table));

	/* cleanup g_alloc_caches */
	for (i = 0, n = RTL_MEMORY_CACHED_SIZES; i < n; i++)
	{
		if (g_alloc_caches[i] != NULL)
		{
			rtl_cache_destroy (g_alloc_caches[i]);
			g_alloc_caches[i] = NULL;
		}
	}

	/* cleanup gp_alloc_arena */
	if (gp_alloc_arena != NULL)
	{
		rtl_arena_destroy (gp_alloc_arena);
		gp_alloc_arena = NULL;
	}
}

/* ================================================================= *
 *
 * custom allocator implementation.
 *
 * ================================================================= */

void *
SAL_CALL rtl_allocateMemory (sal_Size n) SAL_THROW_EXTERN_C()
{
	void * p = 0;
	if (n > 0)
	{
		char *     addr;
		sal_Size   size = RTL_MEMORY_ALIGN(n + RTL_MEMALIGN, RTL_MEMALIGN);

		OSL_ASSERT(RTL_MEMALIGN >= sizeof(sal_Size));
		if (n >= SAL_MAX_SIZE - (RTL_MEMALIGN + RTL_MEMALIGN - 1))
		{
			/* requested size too large for roundup alignment */
			return 0;
		}

try_alloc:
		if (size <= RTL_MEMORY_CACHED_LIMIT)
			addr = (char*)rtl_cache_alloc(g_alloc_table[(size - 1) >> RTL_MEMALIGN_SHIFT]);
		else
			addr = (char*)rtl_arena_alloc (gp_alloc_arena, &size);

		if (addr != 0)
		{
			((sal_Size*)(addr))[0] = size;
			p = addr + RTL_MEMALIGN;
		}
		else if (gp_alloc_arena == 0)
		{
			if (rtl_memory_init())
			{
				/* try again */
				goto try_alloc;
			}
		}
	}
	return (p);
}

/* ================================================================= */

void SAL_CALL rtl_freeMemory (void * p) SAL_THROW_EXTERN_C()
{
	if (p != 0)
	{
		char *   addr = (char*)(p) - RTL_MEMALIGN;
		sal_Size size = ((sal_Size*)(addr))[0];

		if (size <= RTL_MEMORY_CACHED_LIMIT)
			rtl_cache_free(g_alloc_table[(size - 1) >> RTL_MEMALIGN_SHIFT], addr);
		else
			rtl_arena_free (gp_alloc_arena, addr, size);
	}
}

/* ================================================================= */

void * SAL_CALL rtl_reallocateMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C()
{
	if (n > 0)
	{
		if (p != 0)
		{
			void *   p_old = p;
			sal_Size n_old = ((sal_Size*)( (char*)(p) - RTL_MEMALIGN  ))[0] - RTL_MEMALIGN;

			p = rtl_allocateMemory (n);
			if (p != 0)
			{
				memcpy (p, p_old, SAL_MIN(n, n_old));
				rtl_freeMemory (p_old);
			}
		}
		else
		{
			p = rtl_allocateMemory (n);
		}
	}
	else if (p != 0)
	{
		rtl_freeMemory (p), p = 0;
	}
	return (p);
}

#else  /* FORCE_SYSALLOC */

/* ================================================================= *
 *
 * system allocator includes.
 *
 * ================================================================= */

#ifndef INCLUDED_STDLIB_H
#include <stdlib.h>
#define INCLUDED_STDLIB_H
#endif

/* ================================================================= *
 *
 * system allocator implementation.
 *
 * ================================================================= */

void * SAL_CALL rtl_allocateMemory (sal_Size n)
{
	return malloc (n);
}

/* ================================================================= */

void SAL_CALL rtl_freeMemory (void * p)
{
	free (p);
}

/* ================================================================= */

void * SAL_CALL rtl_reallocateMemory (void * p, sal_Size n)
{
	return realloc (p, n);
}

/* ================================================================= */

void
rtl_memory_fini (void)
{
	/* nothing to do */
}

#endif /* FORCE_SYSALLOC */

/* ================================================================= *
 *
 * rtl_(allocate|free)ZeroMemory() implementation.
 *
 * ================================================================= */

void * SAL_CALL rtl_allocateZeroMemory (sal_Size n) SAL_THROW_EXTERN_C()
{
	void * p = rtl_allocateMemory (n);
	if (p != 0)
		memset (p, 0, n);
	return (p);
}

/* ================================================================= */

void SAL_CALL rtl_freeZeroMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C()
{
	if (p != 0)
	{
		memset (p, 0, n);
		rtl_freeMemory (p);
	}
}

/* ================================================================= */