sedna 0.5.1 → 0.6.0

data/vendor/sedna/kernel/common/mmgr/memnodes.h

@@ -0,0 +1,70 @@
+/*
+ * File: memnodes.h
+ *	  Memory context node definitions.
+ *
+ * Portions Copyright (C) 2006 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ */
+
+#ifndef MEMNODES_H
+#define MEMNODES_H
+
+#ifndef SE_MEMORY_TRACK
+/*
+ * MemoryContext
+ *		A logical context in which memory allocations occur.
+ *
+ * MemoryContext itself is an abstract type that can have multiple
+ * implementations, though for now we have only AllocSetContext.
+ * The function pointers in MemoryContextMethods define one specific
+ * implementation of MemoryContext --- they are a virtual function table
+ * in C++ terms.
+ *
+ * Node types that are actual implementations of memory contexts must
+ * begin with the same fields as MemoryContext.
+ *
+ * Note: for largely historical reasons, typedef MemoryContext is a pointer
+ * to the context struct rather than the struct type itself.
+ */
+
+typedef struct MemoryContextMethods
+{
+	void	   *(*alloc) (MemoryContext context, usize_t size);
+	/* call this free_p in case someone #define's free() */
+	void		(*free_p) (MemoryContext context, void *pointer);
+	void	   *(*realloc) (MemoryContext context, void *pointer, usize_t size);
+	void		(*init) (MemoryContext context);
+	void		(*reset) (MemoryContext context);
+	void		(*del) (MemoryContext context);
+	usize_t		(*get_chunk_space) (MemoryContext context, void *pointer);
+	bool		(*is_empty) (MemoryContext context);
+	void		(*stats) (MemoryContext context);
+#ifdef MEMORY_CONTEXT_CHECKING
+	void		(*check) (MemoryContext context);
+#endif
+} MemoryContextMethods;
+
+
+typedef struct MemoryContextData
+{
+	MemoryContextMethods *methods;		/* virtual function table */
+	MemoryContext parent;		/* NULL if no parent (toplevel context) */
+	MemoryContext firstchild;	/* head of linked list of children */
+	MemoryContext nextchild;	/* next child of same parent */
+	char	   *name;			/* context name (just for debugging) */
+} MemoryContextData;
+
+/* se_alloc.h contains typedef struct MemoryContextData *MemoryContext */
+
+
+/*
+ * MemoryContextIsValid
+ *		True iff memory context is valid.
+ */
+#define MemoryContextIsValid(context) \
+	((context) != NULL)
+
+#endif   /* SE_MEMORY_TRACK */
+#endif   /* MEMNODES_H */

data/vendor/sedna/kernel/common/mmgr/memutils.h

@@ -0,0 +1,145 @@
+/*
+ * File: memutils.h
+ *	  This file contains declarations for memory allocation utility
+ *	  functions.  These are functions that are not quite widely used
+ *	  enough to justify going in se_alloc.h, but are still part
+ *	  of the API of the memory management subsystem.
+ *
+ * Portions Copyright (C) 2006 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ */
+#ifndef MEMUTILS_H
+#define MEMUTILS_H
+
+#include "common/mmgr/memnodes.h"
+
+#ifndef SE_MEMORY_TRACK
+
+/*
+ * MaxAllocSize
+ *		Quasi-arbitrary limit on size of allocations.
+ *
+ * Note:
+ *		There is no guarantee that allocations smaller than MaxAllocSize
+ *		will succeed.  Allocation requests larger than MaxAllocSize will
+ *		be summarily denied.
+ *
+ * XXX This is deliberately chosen to correspond to the limiting size
+ * of varlena objects under TOAST.	See VARATT_MASK_SIZE in postgres.h.
+ *
+ * XXX Also, various places in aset.c assume they can compute twice an
+ * allocation's size without overflow, so beware of raising this.
+ */
+#define MaxAllocSize	((usize_t) 0x3fffffff)		/* 1 gigabyte - 1 */
+
+#define AllocSizeIsValid(size)	((usize_t) (size) <= MaxAllocSize)
+
+/*
+ * All chunks allocated by any memory context manager are required to be
+ * preceded by a StandardChunkHeader at a spacing of STANDARDCHUNKHEADERSIZE.
+ * A currently-allocated chunk must contain a backpointer to its owning
+ * context as well as the allocated size of the chunk.	The backpointer is
+ * used by se_free() and se_realloc() to find the context to call. The allocated
+ * size is not absolutely essential, but it's expected to be needed by any
+ * reasonable implementation.
+ */
+typedef struct StandardChunkHeader
+{
+	MemoryContext context;		/* owning context */
+	usize_t		size;			/* size of data space allocated in chunk */
+#ifdef MEMORY_CONTEXT_CHECKING
+	/* when debugging memory usage, also store actual requested size */
+	usize_t		requested_size;
+#endif
+} StandardChunkHeader;
+
+#define STANDARDCHUNKHEADERSIZE  MAXALIGN(sizeof(StandardChunkHeader))
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+ * Standard top-level memory contexts.
+ *
+ * Only TopMemoryContext and ErrorContext are initialized by
+ * MemoryContextInit() itself.
+ */
+extern MemoryContext TopMemoryContext;
+extern MemoryContext ErrorContext;
+
+extern MemoryContext TransactionContext;
+extern MemoryContext UserStatementContext;
+extern MemoryContext KernelStatementContext;
+extern MemoryContext XQParserContext;
+
+
+/*
+ * Memory-context-type-independent functions in mcxt.c
+ */
+extern void MemoryContextInit(void);
+extern int  SafeMemoryContextInit(void);
+extern void MemoryContextReset(MemoryContext context);
+extern void MemoryContextDelete(MemoryContext context);
+extern void MemoryContextResetChildren(MemoryContext context);
+extern void MemoryContextDeleteChildren(MemoryContext context);
+extern void MemoryContextResetAndDeleteChildren(MemoryContext context);
+extern usize_t GetMemoryChunkSpace(void *pointer);
+extern MemoryContext GetMemoryChunkContext(void *pointer);
+extern bool MemoryContextIsEmpty(MemoryContext context);
+extern void MemoryContextStats(MemoryContext context);
+
+#ifdef MEMORY_CONTEXT_CHECKING
+extern void MemoryContextCheck(MemoryContext context);
+#endif
+extern bool MemoryContextContains(MemoryContext context, void *pointer);
+
+/*
+ * This routine handles the context-type-independent part of memory
+ * context creation.  It's intended to be called from context-type-
+ * specific creation routines, and noplace else.
+ */
+extern MemoryContext MemoryContextCreate(usize_t size,
+                                         MemoryContextMethods *methods,
+                                         MemoryContext parent,
+                                         const char *name);
+
+
+/*
+ * Memory-context-type-specific functions
+ */
+
+/* aset.c */
+extern MemoryContext AllocSetContextCreate(MemoryContext parent,
+                                           const char *name,
+                                           usize_t minContextSize,
+                                           usize_t initBlockSize,
+                                           usize_t maxBlockSize);
+
+#ifdef __cplusplus
+}
+#endif
+
+/*
+ * Recommended default alloc parameters, suitable for "ordinary" contexts
+ * that might hold quite a lot of data.
+ */
+#define ALLOCSET_DEFAULT_MINSIZE   0
+#define ALLOCSET_DEFAULT_INITSIZE  (8 * 1024)
+#define ALLOCSET_DEFAULT_MAXSIZE   (8 * 1024 * 1024)
+
+/*
+ * Recommended alloc parameters for "small" contexts that are not expected
+ * to contain much data (for example, a context to contain a query plan).
+ */
+#define ALLOCSET_SMALL_MINSIZE	 0
+#define ALLOCSET_SMALL_INITSIZE  (1 * 1024)
+#define ALLOCSET_SMALL_MAXSIZE	 (8 * 1024)
+
+#endif   /* SE_MEMORY_TRACK */
+
+#endif   /* MEMUTILS_H */

data/vendor/sedna/kernel/common/mmgr/se_alloc.h

@@ -0,0 +1,321 @@
+/*
+ * File: se_alloc.h
+ *	  Memory allocator definitions.
+ *
+ * Portions Copyright (C) 2006 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * This file contains the basic memory allocation interface that is
+ * needed by almost every module. Keep it lean!
+ *
+ * Memory allocation occurs within "contexts".	Every chunk obtained from
+ * se_alloc()/MemoryContextAlloc() is allocated within a specific context.
+ * The entire contents of a context can be freed easily and quickly by
+ * resetting or deleting the context --- this is both faster and less
+ * prone to memory-leakage bugs than releasing chunks individually.
+ * We organize contexts into context trees to allow fine-grain control
+ * over chunk lifetime while preserving the certainty that we will free
+ * everything that should be freed.  See utils/mmgr/README for more info.
+ *
+ */
+
+#ifndef SE_ALLOC_H
+#define SE_ALLOC_H
+
+/// #define SE_MEMORY_MNG
+/// #define SE_MEMORY_TRACK
+
+#ifdef SE_MEMORY_TRACK
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+              
+extern char MT_SEDNA_DATA[];
+extern void *track_malloc(usize_t size, const char* file, int line, const char* flag);
+extern void track_free(void *pointer);
+extern void *track_realloc(void *pointer, usize_t size, const char* file, int line, const char* flag);
+extern void *track_calloc(usize_t num, usize_t size, const char* file, int line, const char* flag);
+extern char *track_strdup(const char *source, const char* file, int line, const char* flag);
+extern void DumpUnfreed(int component);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+
+inline void *operator new(usize_t size, const char *file, int line, const char* flag)
+{
+    return track_malloc(size, file, line, flag);
+}
+inline void operator delete(void* p, const char *file, int line, const char* flag)
+{
+    track_free(p);
+}
+inline void operator delete(void* p)
+{
+    track_free(p);
+}
+inline void *operator new[](usize_t size, const char *file, int line, const char* flag)
+{
+    return track_malloc(size, file, line, flag);
+}
+inline void operator delete[](void* p, const char *file, int line, const char* flag)
+{
+    track_free(p);
+}
+inline void operator delete[](void* p)
+{
+    track_free(p);
+}
+
+#define se_new                     new(__FILE__, __LINE__, "SE_NEW")
+#define se_new_cxt(cxt)            new(__FILE__, __LINE__, "SE_NEW_CXT")
+
+#endif
+
+#define se_delete(p)               delete(p)
+#define se_free(p)                 track_free(p)
+#define se_alloc(size)             track_malloc(size, __FILE__, __LINE__, "SE_ALLOC")
+#define se_realloc(pointer, size)  track_realloc(pointer, size, __FILE__, __LINE__, "SE_REALLOC")
+
+#define malloc(size)               track_malloc(size, __FILE__, __LINE__, "MALLOC")
+#define free(pointer)              track_free(pointer)
+#define realloc(pointer, size)     track_realloc(pointer, size, __FILE__, __LINE__, "REALLOC")
+#define calloc(num, size)          track_calloc(num, size, __FILE__, __LINE__, "CALLOC")
+#define strdup(source)             track_strdup(source, __FILE__, __LINE__, "STRDUP")
+
+#else /* SE_MEMORY_TRACK */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Type MemoryContextData is declared in nodes/memnodes.h.	Most users
+ * of memory allocation should just treat it as an abstract type, so we
+ * do not provide the struct contents here.
+ */
+typedef struct MemoryContextData *MemoryContext;
+
+/*
+ * CurrentMemoryContext is the default allocation context for se_alloc().
+ * We declare it here so that se_alloc() can be a macro.	Avoid accessing it
+ * directly!  Instead, use MemoryContextSwitchTo() to change the setting.
+ */
+extern MemoryContext CurrentMemoryContext;
+
+/*
+ * Fundamental memory-allocation operations (more are in utils/memutils.h)
+ */
+extern void *MemoryContextAlloc(MemoryContext context, usize_t size);
+extern void *MemoryContextAllocZero(MemoryContext context, usize_t size);
+extern void *MemoryContextAllocZeroAligned(MemoryContext context, usize_t size);
+
+#ifdef SE_MEMORY_MNG
+#define se_alloc(sz)    MemoryContextAlloc(CurrentMemoryContext, (sz))
+
+#define se_alloc0(sz)   MemoryContextAllocZero(CurrentMemoryContext, (sz))
+#else
+#define se_alloc        malloc
+#endif
+
+/*
+ * The result of se_alloc() is always word-aligned, so we can skip testing
+ * alignment of the pointer when deciding which MemSet variant to use.
+ * Note that this variant does not offer any advantage, and should not be
+ * used, unless its "sz" argument is a compile-time constant; therefore, the
+ * issue that it evaluates the argument multiple times isn't a problem in
+ * practice.
+ */
+#ifdef SE_MEMORY_MNG
+#define se_alloc0fast(sz) \
+	( MemSetTest(0, sz) ? \
+		MemoryContextAllocZeroAligned(CurrentMemoryContext, sz) : \
+		MemoryContextAllocZero(CurrentMemoryContext, sz) )
+#endif
+
+
+extern void se_free(void *pointer);
+
+extern void *se_realloc(void *pointer, usize_t size);
+
+/*
+ * MemoryContextSwitchTo can't be a macro in standard C compilers.
+ * But we can make it an inline function when using GCC.
+ */
+#ifdef __GNUC__
+static __inline__ MemoryContext
+MemoryContextSwitchTo(MemoryContext context)
+{
+	MemoryContext old = CurrentMemoryContext;
+
+	CurrentMemoryContext = context;
+	return old;
+}
+#else
+extern MemoryContext MemoryContextSwitchTo(MemoryContext context);
+#endif   /* __GNUC__ */
+
+/*
+ * These are like standard strdup() except the copied string is
+ * allocated in a context, not with malloc().
+ */
+extern char *MemoryContextStrdup(MemoryContext context, const char *string);
+
+#ifdef SE_MEMORY_MNG
+#define se_strdup(str)  MemoryContextStrdup(CurrentMemoryContext, (str))
+#else
+#define se_strdup       strdup
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#ifdef __cplusplus
+
+/*
+ * AF:
+ * We can overload global new and global delete to use our Context
+ * memory allocation routines. But for this moment we prefer not to
+ * do that but rather to define placement new and placement delete
+ * (with parameter MemoryContext). Placement delete is implemented
+ * by the template function se_destroy, which calls destructor 
+ * explicitly.
+ * To conclude, STL routines are using default new and delete operators
+ * (we can count on them that they do not have memory leaks). For
+ * Sedna code we should use se_new and se_new_cxt macroses to allocate
+ * memory and se_delete to deallocate memory. Note that se_new and 
+ * se_new_cxt call constructor and se_delete calls destructor correctly.
+ * Note that we still could call global new and delete operators
+ * that are not overloaded.
+ *
+ * Example:
+ * A *a = NULL;
+ * int *i = NULL;
+ *
+ * // our new operator in CurrentMemoryContext
+ * a = se_new A(some_parameters ...); 
+ * se_delete(a); // destructor will be called
+ *
+ * // our new operator in TopMemoryContext
+ * a = se_new_cxt(TopMemoryContext) A(some_parameters ...);
+ * se_delete(a); // destructor will be called
+ *
+ * // Simple types are also supported correctly
+ * i = se_new int;
+ * se_delete(i);
+ */
+
+/* !!! Uncomment this if you want to replace global new and global
+       delete.
+
+inline void *operator new(usize_t size)
+{
+    return operator_new_global(size);
+}
+
+inline void operator delete(void* p)
+{
+    if (p) se_free(p);
+}
+
+inline void *operator new[](usize_t size)
+{
+    return operator_new_global(size);
+}
+
+inline void operator delete[](void* p)
+{
+    if (p) se_free(p);
+}
+*/
+
+/*
+ * Inline new and delete operators rely on these definitions.
+ * 
+ */
+extern "C" int SafeMemoryContextInit(void);
+extern "C" MemoryContext TopMemoryContext;
+
+
+
+inline void *operator new(usize_t size, MemoryContext context)
+{
+#ifdef SE_MEMORY_MNG
+    if (SafeMemoryContextInit()) context = TopMemoryContext;
+    return MemoryContextAlloc(context, size);
+#else
+    return malloc(size);
+#endif
+}
+
+inline void operator delete(void* p, MemoryContext context)
+{
+#ifdef SE_MEMORY_MNG
+    if (p) se_free(p);
+#else
+    if (p) free(p);
+#endif
+}
+
+inline void *operator new[](usize_t size, MemoryContext context)
+{
+#ifdef SE_MEMORY_MNG
+    if (SafeMemoryContextInit()) context = TopMemoryContext;
+    return MemoryContextAlloc(context, size);
+#else
+    return malloc(size);
+#endif
+}
+
+inline void operator delete[](void* p, MemoryContext context)
+{
+#ifdef SE_MEMORY_MNG
+    if (p) se_free(p);
+#else
+    if (p) free(p);
+#endif
+}
+
+template<class T> void __se_delete(T* p, MemoryContext context)
+{
+    if (p) 
+    {
+        p->~T();
+#ifdef SE_MEMORY_MNG
+        se_free(p);
+#else
+        free(p);
+#endif
+    }
+}
+
+// FIXME: remove this when Sedna memory manager will be ready (AF)
+#ifdef SE_MEMORY_MNG
+inline void operator delete(void* p)
+{
+}
+inline void operator delete[](void* p)
+{
+}
+#endif
+
+
+#ifdef SE_MEMORY_MNG
+#define se_new                  new(CurrentMemoryContext)
+#define se_new_cxt(cxt)         new(cxt)
+#define se_delete(p)            __se_delete(p, NULL)
+#else
+#define se_new                  new
+#define se_new_cxt(cxt)         new
+#define se_delete(p)            delete(p);
+#endif
+
+#endif   /* __cplusplus__   */
+#endif   /* SE_MEMORY_TRACK */
+#endif   /* SE_ALLOC_H      */