sedna 0.5.1 → 0.6.0

data/vendor/sedna/kernel/common/ugc.h

@@ -0,0 +1,15 @@
+/*
+ * File:  ugc.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _UGC_H
+#define _UGC_H
+
+void gov_ugc(bool background_off_from_background_on, int os_primitives_bound);
+
+void sm_ugc(bool background_off_from_background_on, int db_id, int os_primitives_bound);
+
+void cdb_ugc(int db_id, int os_primitives_bound);
+
+#endif

data/vendor/sedna/kernel/common/utils.cpp

@@ -0,0 +1,156 @@
+/*
+ * File:  utils.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#include <math.h>
+
+#include "common/sedna.h"
+
+#include "common/utils.h"
+#include "common/u/uutils.h"
+#include "common/errdbg/d_printf.h"
+#include "common/u/uhdd.h"
+
+#ifndef _WIN32
+#include <strings.h>
+#endif
+
+
+using namespace std;
+
+string int2string(__int64 value)
+{
+    char buf[20];
+    u_i64toa(value, buf, 10);
+    return string(buf);
+}
+
+string to_string(u_timeb t)
+{
+    char buf[80];
+    sprintf(buf, "%d.%03ld", (int)t.time, t.millitm);
+    return string(buf);
+}
+
+double power(double a, double b)
+{
+    return exp(b * log(a));
+}
+
+#ifndef _WIN32
+int _isnan(double x)
+{
+    return isnan(x);
+}
+#endif
+    
+void elim_disturb(void *base, size_t num, size_t width, compare_fun compare)
+{
+    int pos = -1;
+    bool growing = true;
+    int i = 0;
+    for (i = 0; i < (int)num - 1; i++)
+        if (compare((char*)base + i * width, (char*)base + (i + 1) * width) > 0)
+        {
+            if (i + 2 < (int)num)
+            {
+                if (compare((char*)base + i * width, (char*)base + (i + 2) * width) > 0)
+                    pos = i;
+                else { pos = i + 1; growing = false; }
+            }
+            else { pos = i + 1; growing = false; }
+
+            break;
+        }
+
+    if (pos == -1) return;
+
+    char * tmp = se_new char[width];
+
+    if (growing)
+    {
+        for (i = pos; i < (int)num - 1; i++)
+            if (compare((char*)base + i * width, (char*)base + (i + 1) * width) > 0)
+            {
+                /* swap*/
+                memcpy(tmp, (char*)base + i * width, width);
+                memcpy((char*)base + i * width, (char*)base + (i + 1) * width, width);
+                memcpy((char*)base + (i + 1) * width, tmp, width);
+            }
+            else break;
+    }
+    else
+    {
+        for (i = pos; i > 0; i--)
+            if (compare((char*)base + (i - 1) * width, (char*)base + i * width) > 0)
+            {
+                /* swap*/
+                memcpy(tmp, (char*)base + i * width, width);
+                memcpy((char*)base + i * width, (char*)base + (i - 1) * width, width);
+                memcpy((char*)base + (i - 1) * width, tmp, width);
+            }
+            else break;
+    }
+
+    delete [] tmp;
+}
+
+void elim_disturb2(void *base, size_t num, size_t width, compare_fun compare)
+{
+    int lb = 0, rb = 0, med = 0;
+    int pos = 0, cmp = 0;
+
+    lb = 1; 
+    rb = num;
+
+    if (num == 1) return;
+
+    while (true)
+    {
+        if (rb - lb == 1)
+        {
+            if (compare(base, (char*)base + lb * width) <= 0) pos = lb;
+            else
+            {
+                if (compare(base, (char*)base + rb * width) <= 0) pos = rb;
+                else pos = rb + 1;
+            }
+            break;
+        }
+
+        med = (rb + lb) / 2;
+        cmp = compare(base, (char*)base + med * width);
+
+        if (cmp < 0) rb = med;
+        else 
+            if (cmp > 0) lb = med;
+            else
+            {
+                pos = med;
+                break;
+            }
+    }
+
+    if (pos == 1) return;
+
+    /* swap*/
+    char * tmp = se_new char[width];
+
+    memcpy(tmp, base, width);
+    memmove(base, (char*)base + width, width * (pos - 1));
+    memcpy((char*)base + width * (pos - 1), tmp, width);
+
+    delete [] tmp;
+}
+
+std::string trim(const std::string& str)
+{
+    std::string::size_type start = str.find_first_not_of(" \n\t\r");
+    std::string::size_type end   = str.find_last_not_of(" \n\t\r");
+    if (start == std::string::npos || end == std::string::npos)
+        return "";
+    return str.substr(start, end - start + 1);
+}
+
+

data/vendor/sedna/kernel/common/utils.h

@@ -0,0 +1,133 @@
+/*
+ * File:  utils.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef __UTILS_H
+#define __UTILS_H
+
+#include <string>
+#include <vector>
+
+#include "common/sedna.h"
+
+
+#define MBS2PAGES(s)   ((int64_t) (s) * (int64_t)0x100000 / (int64_t) PAGE_SIZE)
+#define PAGES2MBS(s)   ((int64_t) (s) * (int64_t)PAGE_SIZE / (int64_t) 0x100000)
+
+
+std::string int2string(__int64 value);
+
+/* datatypes and functions to with time (time in sec + time in millisec)*/
+#ifndef _WIN32
+struct _timeb
+{
+    long time;
+    long millitm;
+    int timezone;
+    int dstflag;
+};
+#endif
+
+typedef _timeb u_timeb;
+
+#ifdef _WIN32
+inline void u_ftime(u_timeb *t) {_ftime((t)); }
+#else
+inline void u_ftime(u_timeb *t)
+{
+    struct timeval tv;
+    struct timezone tz;
+    /* ftime() is obsolete in FreeBSD 6.2 and higher */
+    gettimeofday(&tv, &tz);    
+    t->time     = tv.tv_sec;
+    t->millitm  = tv.tv_usec/1000;
+    t->dstflag  = tz.tz_dsttime;
+    t->timezone = tz.tz_minuteswest; 
+}
+#endif /* _WIN32 */
+
+
+inline void u_timeb_init(u_timeb *t)
+{
+    t->time = 0;
+    t->millitm = 0;
+    t->timezone = 0;
+    t->dstflag = 0;
+}
+
+inline u_timeb operator- (const u_timeb& t1, const u_timeb& t2)
+{
+    u_timeb t;
+    if (t2.millitm > t1.millitm) {
+        t.time = t1.time - t2.time - 1;
+        t.millitm = 1000 - t2.millitm + t1.millitm;
+    }
+    else  {
+        t.time = t1.time - t2.time;
+        t.millitm = t1.millitm - t2.millitm;
+    }
+    t.dstflag = t1.dstflag;
+    t.timezone = t1.timezone;
+    return t;
+}
+
+inline u_timeb operator+ (const u_timeb& t1, const u_timeb& t2)
+{
+    u_timeb t;
+    t.millitm  = t1.millitm + t2.millitm;
+    t.time     = t1.time + t2.time;
+    if(t.millitm > 1000) { t.time++; t.millitm-=1000; }
+    t.dstflag = t1.dstflag;
+    t.timezone = t1.timezone;
+    return t;
+}
+
+std::string to_string(u_timeb t);
+
+double power(double a, double b);
+
+#ifndef _WIN32
+int _isnan(double x);
+#endif
+    
+template<class T>
+std::vector<T> vector_concat(const std::vector<T>& v1, const std::vector<T> &v2)
+{
+    std::vector<T> res;
+
+    res.reserve(v1.size() + v2.size());
+
+    typename std::vector<T>::const_iterator it;
+    for (it = v1.begin(); it != v1.end(); it++) res.push_back(*it);
+    for (it = v2.begin(); it != v2.end(); it++) res.push_back(*it);
+
+    return res;
+}
+
+
+/* function is used for eliminating disturbance from sorted array*/
+/* parameters are like parameters for qsort*/
+#ifdef _WIN32
+typedef int (__cdecl *compare_fun)(const void* elem1, const void* elem2);
+#else
+typedef int (*compare_fun)(const void* elem1, const void* elem2);
+#endif
+void elim_disturb(void *base, size_t num, size_t width, compare_fun compare);
+void elim_disturb2(void *base, size_t num, size_t width, compare_fun compare);
+
+std::string trim(const std::string& str);
+
+/// Intented to be used with strcmp and memcmp
+///     res = memcmp(ptr1, ptr2)
+///     return sign(res)
+/// In such a way we will guarantee -1 and 1 values.
+inline int sign(int i)
+{
+    if (i > 0) return 1;
+    if (i < 0) return -1;
+    return i;
+}
+
+#endif /* __UTILS_H */

data/vendor/sedna/kernel/common/version.c

@@ -0,0 +1,16 @@
+/*
+ * File:  version.c
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#include "common/sedna.h"
+
+void print_version_and_copyright(const char *prog_name)
+{
+    const char* ver = SEDNA_VERSION;
+    const char* build = SEDNA_BUILD;
+    fprintf(stdout, "%s Version %s.%s\n", prog_name, ver, build);
+    fprintf(stdout, "Copyright (C) 2004-2009 ISP RAS and others. All rights reserved.\n"); 
+    fprintf(stdout, "See file COPYRIGHT provided with the distribution.\n");   
+}

data/vendor/sedna/kernel/common/version.h

@@ -0,0 +1,21 @@
+/*
+ * File:  version.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _VERSION_H
+#define _VERSION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif 
+	
+void print_version_and_copyright(const char *prog_name);
+
+#ifdef __cplusplus
+}
+#endif 
+
+#endif
+

data/vendor/sedna/kernel/common/wustructures.h

@@ -0,0 +1,18 @@
+#if (_MSC_VER > 1000)
+#pragma once
+#endif
+
+#ifndef WUSTRUCTURES_INCLUDED
+#define WUSTRUCTURES_INCLUDED
+
+#include "wutypes.h"
+
+#define	VE_VERSIONS_COUNT		4
+
+struct VersionsHeader
+{
+	XPTR xptr[VE_VERSIONS_COUNT];
+	TIMESTAMP creatorTs[VE_VERSIONS_COUNT];
+};
+
+#endif

data/vendor/sedna/kernel/common/wutypes.h

@@ -0,0 +1,34 @@
+#include <stdint.h>
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+#ifndef WUTYPES_INCLUDED
+#define WUTYPES_INCLUDED
+
+typedef uint64_t XPTR, LXPTR;
+typedef uint64_t TIMESTAMP;
+typedef void *TICKET;
+
+
+/* [TIMESTAMP_MIN, TIMESTAMP_MAX] is the range of valid timestamps; values outside this
+   range have the special interpretation. One of the special timestamp values is
+   INVALID_TIMESTAMP. Other "special" values may have a module-specific meaning
+   or may be used internally for some purposes. */ 
+#define TIMESTAMP_MIN		UINT64_C(0x0000000000010000)
+#define TIMESTAMP_MAX		UINT64_C(0xFFFFFFFFFFFF0000)
+
+inline
+static
+bool IsValidTimestamp(TIMESTAMP ts)
+{
+	return ts>=TIMESTAMP_MIN && ts<=TIMESTAMP_MAX;
+}
+
+/* INVALID_TIMESTAMP is the greatest possible value for the variable of TIMESTAMP type */ 
+#define INVALID_TIMESTAMP	UINT64_C(0xFFFFFFFFFFFFFFFF)
+
+#define INVALID_TICKET		NULL
+
+#endif

data/vendor/sedna/kernel/common/xptr.cpp

@@ -0,0 +1,17 @@
+/*
+ * File:  xptr.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#include "common/sedna.h"
+
+#include "common/xptr.h"
+#include "common/errdbg/d_printf.h"
+
+void xptr::print() const
+{ 
+    d_printf3("(layer, addr) = (%d, 0x%x)\n", (int)layer, (unsigned int)addr); 
+}
+
+

data/vendor/sedna/kernel/common/xptr.h

@@ -0,0 +1,211 @@
+/*
+ * File:  xptr.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef __XPTR_H
+#define __XPTR_H
+
+#include "common/sedna.h"
+#include "common/base.h"
+
+#ifndef NULL
+#define NULL_WAS_NOT_DEFINED
+#define NULL	0
+#endif
+
+// File incapsulates xptr notion. It has been written for 32-bit architecture
+// but with the goal to be easyly ported to 64-bit architecture
+
+#define TMP_LAYER_STARTS_WITH	0x40000000
+#define INVALID_LAYER			0xFFFFFFFF
+
+// user this macros when you want obtain pointer in terms of process' virtual
+// address space
+#define XADDR(p)				((p).addr)
+#define CONSTRUCT_XPTR(l, a)	(xptr(l, a))
+#define BLOCKXPTR(a)			cxptr(a.layer,(void*)((__uint32)((a).addr) & PAGE_BIT_MASK))
+
+#define ADDR2XPTR(a)			cxptr(*(t_layer*)(((__uint32)(a)) & PAGE_BIT_MASK),					\
+                                     (void*)(*(__uint32*)((((__uint32)(a)) & PAGE_BIT_MASK) + sizeof(t_layer)) + (((__uint32)(a)) & PAGE_REVERSE_BIT_MASK)))
+#define TEST_XPTR(p)			(*(t_layer*)((__uint32)((p).addr) & PAGE_BIT_MASK) == (p).layer)
+//#define TEST_XPTR(p)            ((* (xptr *) XADDR(p)) == p)
+#define ALIGN_ADDR(a)			((void*)((__uint32)(a) & PAGE_BIT_MASK))
+#define LAYERS_EQUAL(a, p)      (*(t_layer*)((__uint32)(a) & PAGE_BIT_MASK) == ((p).layer))
+
+
+
+#define IS_TMP_BLOCK(p)			((p).layer >= TMP_LAYER_STARTS_WITH)
+#define IS_DATA_BLOCK(p)		((p).layer <  TMP_LAYER_STARTS_WITH)
+
+#define IS_TMP_BLOCK_LP(ptr)	(((vmm_sm_blk_hdr*)(ptr))->p.layer >= TMP_LAYER_STARTS_WITH)
+#define IS_DATA_BLOCK_LP(ptr)	(((vmm_sm_blk_hdr*)(ptr))->p.layer <  TMP_LAYER_STARTS_WITH)
+
+//struct vmm_sm_blk_hdr;
+
+/* type for layer */
+typedef int t_layer;
+
+union uint64_lh_t { struct uint64_lh { uint32_t l; uint32_t h; } lh; uint64_t v; };
+
+/* Struct for Extended Virtual Address Space Pointer */
+struct xptr
+{
+    t_layer	layer;
+    void *	addr;
+
+    inline uint64_t to_logical_int() const {
+        union uint64_lh_t v = * (uint64_lh_t *) this;
+#ifndef BIG_ENDIAN_ORDER
+        uint32_t x = v.lh.l;
+        v.lh.l = v.lh.h;
+        v.lh.h = x;
+#endif
+        return v.v;
+    };
+
+    inline uint64_t to_uint64() const { return * (uint64_t *) this; };
+    inline void from_uint64(const uint64_t x) const { (* (uint64_t *) this) = x; };
+
+    xptr &operator +=(int n)
+	{
+		addr = (char*)(addr) + n;
+
+		if ((unsigned int)addr >= LAYER_ADDRESS_SPACE_BOUNDARY_INT)
+		{
+			layer++;
+			addr = (void*)((int)addr - LAYER_ADDRESS_SPACE_SIZE);
+		}
+
+		return *this;
+	}
+    xptr &operator -=(int n)
+    {
+        addr = (char*)(addr) - n;
+
+        if ((unsigned int)addr < LAYER_ADDRESS_SPACE_START_ADDR_INT)
+		{
+			layer--;
+			addr = (void*)((int)addr + LAYER_ADDRESS_SPACE_SIZE);
+		}
+
+        return *this;
+    }
+
+    void print() const;
+    void clear() { layer = 0; addr = NULL; }
+};
+
+inline xptr uint64_to_xptr(const uint64_t x) {
+    xptr p;
+    p.from_uint64(x);
+    return p;
+};
+
+inline xptr cxptr(t_layer l, void * a) {
+    xptr p = {l, a};
+    return p;
+}
+
+inline xptr operator+(const xptr &p, int n)
+{
+    xptr new_p(p);
+    new_p.addr = (char*)(p.addr) + n;
+
+    if ((unsigned int)(new_p.addr) >= LAYER_ADDRESS_SPACE_BOUNDARY_INT)
+    {
+        new_p.layer++;
+        new_p.addr = (void*)((int)(new_p.addr) - LAYER_ADDRESS_SPACE_SIZE);
+    }
+
+    return new_p;
+}
+
+inline xptr operator-(const xptr &p, int n)
+{
+    xptr new_p(p);
+    new_p.addr = (char*)(p.addr) - n;
+
+    if ((unsigned int)(new_p.addr) < LAYER_ADDRESS_SPACE_START_ADDR_INT)
+    {
+        new_p.layer--;
+        new_p.addr = (void*)((int)(new_p.addr) + LAYER_ADDRESS_SPACE_SIZE);
+    }
+
+    return new_p;
+}
+
+inline __uint32 operator-(const xptr &p1, const xptr &p2)
+{
+    if (p1.layer != p2.layer) throw USER_EXCEPTION2(SE1003, "Bad paramters in xptr operator-(const xptr &p1, const xptr &p2)");
+    return (__uint32)(p1.addr) - (__uint32)(p2.addr);
+}
+
+inline bool operator==(const xptr &p1, const xptr &p2)
+{
+    return p1.addr == p2.addr && (p1.addr == NULL || p1.layer == p2.layer);
+}
+
+inline bool operator!=(const xptr &p1, const xptr &p2)
+{
+    return !(p1 == p2);
+}
+
+inline bool operator<(const xptr &p1, const xptr &p2)
+{
+    return (p1.layer != p2.layer ? p1.layer < p2.layer : (__uint32)(p1.addr) < (__uint32)(p2.addr));
+}
+
+inline xptr block_xptr(const xptr &p)
+{
+    return cxptr(p.layer, (void*)((__uint32)(p.addr) & PAGE_BIT_MASK));
+}
+
+inline xptr addr2xptr(const void * p)
+{
+    U_ASSERT(((xptr *) (((uint32_t) p ) & PAGE_BIT_MASK))->addr == (void *) (((uint32_t) p ) & PAGE_BIT_MASK));
+    return cxptr(* (t_layer*) (((uint32_t) p) & PAGE_BIT_MASK), const_cast<void *>(p));
+}
+
+inline void shed_state(xptr &p)
+{
+    p.layer = 0;
+    p.addr = NULL;
+}
+
+
+inline int xptr_compare(const xptr& p1, const xptr& p2)
+{
+    if (p1.addr == NULL && p2.addr == NULL) return 0;
+    if (p1.addr == NULL) return 1;
+    if (p2.addr == NULL) return -1;
+
+    if(p1.layer != p2.layer)
+    {
+        return p1.layer < p2.layer ? -1 : 1;
+    }
+    else
+    {
+        if((__uint32)(p1.addr) < (__uint32)(p2.addr)) return -1;
+        else if((__uint32)(p1.addr) == (__uint32)(p2.addr)) return 0;
+        return 1;
+    }
+}
+
+inline bool same_block(const xptr& a, const xptr& b) {
+    return (BLOCKXPTR(a) == BLOCKXPTR(b));
+}
+
+inline bool isTmpBlock(const xptr &p) { return p.layer >= TMP_LAYER_STARTS_WITH; };
+
+/* NULL for xpointers */
+const xptr XNULL = {};
+
+#ifdef NULL_WAS_NOT_DEFINED
+#undef NULL
+#endif
+
+#endif
+
+