sedna 0.5.1 → 0.6.0

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

@@ -0,0 +1,142 @@
+/*
+ * File:  SSMMsg.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef __SSMMsg_H
+#define __SSMMsg_H
+
+// SSMMsg stands for Simple Shared Memory Messages Client/Server Architecture
+
+#include <string>
+
+#include "common/sedna.h"
+
+#include "common/u/usem.h"
+#include "common/u/uthread.h"
+#include "common/u/ushm.h"
+
+#define SSMMSG_DEFAULT_TIMEOUT		10000
+
+
+
+// function that serves client msg on the server side
+// it has only arg - addres of block with input data; output data must be 
+// written at the same block
+typedef int (*process_msg_func)(void *);
+
+class SSMMsg;
+
+struct SSMMsg_server_thread_param
+{
+    process_msg_func func;
+    SSMMsg *ssmmsg;
+    int i;
+};
+
+
+class SSMMsg
+{
+    friend U_THREAD_PROC(SSMMsg_server_proc, arg);
+
+public: 
+    // type mode for SSMMsg object
+    enum mode {Server, Client};
+
+private:
+    mode m;
+    int msg_size; 
+    int servers_amount;
+
+    int real_block_size;
+    int shared_memory_size;
+    int *waiting;
+    int *slot;
+    int *process_messages; // is server accept messages (1 - accept, 0 - don't accept)
+    int *busy_servers_amount; // amount of the busy servers
+    void *shar_mem;
+    void *buf_addr;
+    void *sysinf_addr;
+    int sems_num;
+
+    char g_names__buf__ [256];
+
+    global_name g_name_shmem;
+    global_name g_name_sems;
+
+
+    SSMMsg_server_thread_param *server_param;
+
+    unsigned int millisec;
+
+
+    UTHANDLE *thread_handles;
+    UShMem sh_mem;
+    USemaphoreArr sems;
+/*
+    Semaphore array sems consists of the following semaphores:
+    semaphore            initial value
+    ----------------------------------
+    sem_clients				0
+    sem_servers				0
+    sem_mutex				1
+
+    sem_pact				1
+    sem_pact_written		0
+    sem_pact_read			0
+
+    sem_data_written[]		0
+    sem_data_processed[]	0
+    sem_data_read[]			0
+*/
+
+    bool shutdown_server_proc;
+
+public:
+
+    // initializing SSMMsg object
+    // constructor has four parameters:
+    // m - mode, in which object should work
+    // msg_size - size for memory region that will store intermediate data (size
+    // must be specified in bytes, but notice that it will be round up
+    // to page size (4Kb on x86)) 
+    // shared_memory_name - name of shared memory region (unique name in the 
+    // system) 
+    // servers_amount - amount of server threads
+    // msg_size, shared_memory_name, servers_amount must be the same at the 
+    // server side and at all clients (system doesn't control it, so be 
+    // careful)
+    SSMMsg(mode _m_, 
+           int _msg_size_, 
+           global_name _g_name_, 
+           int _servers_amount_, 
+           unsigned int _millisec_ = SSMMSG_DEFAULT_TIMEOUT);
+
+
+    // for all functions below assumed that they return 0 as success and 1 otherwise
+
+    // init object (call it before using object)
+    int init();
+
+    // shutdown object (call it to free resources)
+    int shutdown();
+
+    // send msg to server and wait for answer (this is blocking operation)
+    // buf contains data sending to server and it will contains result if function
+    // completes successfully (assumes that size of buf is msg_size)
+    int send_msg(void * buf);
+
+    // starts serving clients 
+    // it has only one arg - a function that processing msg
+    int serve_clients(process_msg_func func);
+
+    // stops accept new messages and wait until all processing messages finish
+    int stop_serve_clients();
+
+    static void ipc_cleanup(global_name name);
+};
+
+
+#endif
+

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

@@ -0,0 +1,435 @@
+/*
+ * File:  XptrHash.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _XPTRHASH_H
+#define _XPTRHASH_H
+
+#include "common/sedna.h"
+#include "common/xptr.h"
+
+// T - value type
+// 32-bit part of xptr is hashed by the following template:
+// 000000...001111................11110000.........0000
+// \_________/\______________________/\_______________/
+//             middle_significan_bits  right_zero_bits
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+class XptrHash
+{
+private:
+
+    struct add_cell
+    {
+        xptr key;
+        T val;
+        add_cell *next;
+    };
+
+    struct cell 
+    {
+        xptr key;
+        T val;
+        add_cell *next;
+        bool is_present;
+    };
+
+    __uint32 templ;
+
+    typedef cell t_tbl[1 << middle_significan_bits];
+
+    t_tbl tbl;
+    int num;
+
+
+
+    class xhit
+    {
+        private:
+        int pos;
+        add_cell *p;
+        XptrHash *hash;
+
+        xhit &next() 
+        {
+            bool flag = true;
+            if (p != NULL) 
+            {
+                p = p->next;
+                if (p == NULL) flag = false;
+            }
+
+            if (p == NULL)
+            {
+                if (flag && hash->tbl[pos].next != NULL) 
+                    p = hash->tbl[pos].next;
+                else
+                    while (++pos < (1 << middle_significan_bits)) 
+                        if (hash->tbl[pos].is_present) break;
+            }
+
+            return *this;
+        }
+
+        xhit(int _pos_, add_cell *_p_, XptrHash *_hash_) : pos(_pos_), p(_p_), hash(_hash_) {}
+
+    public:
+        static xhit begin(XptrHash *_hash_) { xhit x(0, NULL, _hash_); return _hash_->tbl[0].is_present ? x : x.next(); }
+        static xhit end(XptrHash *_hash_) { return xhit(1 << middle_significan_bits, NULL, _hash_); }
+
+        xhit() : pos(0), p(NULL), hash(NULL) {}
+        xhit(const xhit& x) : pos(x.pos), p(x.p), hash(x.hash) {}
+        xhit& operator=(const xhit &x) { pos = x.pos; p = x.p; hash = x.hash; return *this; }
+
+        bool operator==(const xhit &x) { return hash == x.hash && ((p == x.p && p != NULL) || (p == x.p && p == NULL && pos == x.pos)); }
+        bool operator!=(const xhit &x) { return !operator==(x); }
+    
+        const xptr &getKey()
+        {
+        	if (p == NULL)
+        	{
+        		if (pos >= (1 << middle_significan_bits)) 
+        			throw SYSTEM_EXCEPTION("Out of bounds");
+        		else
+        		    return hash->tbl[pos].key;
+        	}
+        	else
+        		return p->key;
+        }
+
+        xhit &operator++() { return next(); }
+        const T &operator*()
+        {
+            if (p == NULL)
+            {
+                if (pos >= (1 << middle_significan_bits)) throw SYSTEM_EXCEPTION("Out of bounds");
+                else return hash->tbl[pos].val;
+            }
+            else return p->val;
+        }
+    };
+
+public:
+
+    friend class xhit;
+
+    typedef xhit iterator;
+
+    XptrHash();
+    ~XptrHash();
+
+    // functions return 0 if all OK    
+
+    int insert(xptr key, T val);
+    int find(xptr key, T &val);
+    int remove(xptr key);
+    int find_remove(xptr key, T &val);
+    int replace(xptr key, const T &new_val, T &old_val);
+    void clear();
+
+	size_t size() const { return (size_t)num; }
+
+    iterator begin() { return xhit::begin(this); }
+    iterator end() { return xhit::end(this); }
+};
+
+
+
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+XptrHash<T, middle_significan_bits, right_zero_bits>::XptrHash() 
+{
+    __uint32 k = (__uint32)32 - middle_significan_bits - right_zero_bits;
+    templ = (__uint32)0xFFFFFFFF << k >> k >> right_zero_bits << right_zero_bits;
+
+    for (__uint32 i = 0; i < ((__uint32)1 << middle_significan_bits); i++)
+    {
+        tbl[i].next = NULL;
+        tbl[i].key.clear();
+        tbl[i].is_present = false;
+    }
+
+    num = 0;
+}
+
+
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+XptrHash<T, middle_significan_bits, right_zero_bits>::~XptrHash() 
+{
+    clear();
+}
+
+/*
+	Multiple entries with the same key may exist!!!
+*/ 
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+int XptrHash<T, middle_significan_bits, right_zero_bits>::insert(xptr key, T val)
+{
+//    T val1;
+//    if (find(key, val1) == 0) throw USER_ENV_EXCEPTION("xxx", false);
+    cell &start = tbl[((__uint32)(XADDR(key)) & templ) >> right_zero_bits];
+    if (start.is_present)
+    {
+        add_cell * new_cell = se_new add_cell;
+        new_cell->key = key;
+        new_cell->val = val;
+        new_cell->next = start.next;
+        start.next = new_cell;
+    }
+    else 
+    {
+        start.key = key;
+        start.val = val;
+        start.next = NULL;
+        start.is_present = true;
+    }
+   
+    num++;
+
+    return 0;
+}
+
+
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+int XptrHash<T, middle_significan_bits, right_zero_bits>::find(xptr key, T &val)
+{
+    cell &start = tbl[((__uint32)(XADDR(key)) & templ) >> right_zero_bits];
+    if (start.is_present)
+    {
+        if (start.key == key)
+        {
+            val = start.val;
+            return 0;
+        }
+
+        add_cell * p = start.next;
+        for (; p != NULL; p = p->next)
+        {
+            if (p->key == key)
+            {
+                val = p->val;
+                return 0;
+            }
+        }
+        return 1;
+    }
+    else return 1;
+
+    return 0;
+}
+
+
+/*
+	Remove from XPtrHash invalidates all iterators!
+	Consider the following standard example:
+
+	Container container;
+	for (Container::iterator it=container.begin(); it!=container.end(); false)
+	{
+		Container::iterator temp=it;
+		++it;						// (1)
+		Container.remove(temp);		// (2)
+	}
+
+	If you swap (1) and (2) you are in trouble, at least with STL.
+	XptrHash doesn't have a remove(Iterator) function, however it
+	has remove-by-key function which has the same issues.
+
+	See code below for labels (A,B,C).
+	(A) Removing an element that is stored in tbl[] invalidates a iterator
+		pointing to the first element in the collision list attached to the same cell.
+		An iterator pointing to the removed element is now pointing to the former first
+		element of the list.
+	(B,C) Removing an element from collision list invalidates iterators pointing
+		to the removed element. Other iterators are not affected.
+
+	The outlined inconsistency in iterator invalidation rules makes it impossible
+	to write a safe code that does for-each-element-remove-those-that-meet-some-condition with
+	XptrHash.
+*/ 
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+int XptrHash<T, middle_significan_bits, right_zero_bits>::remove(xptr key)
+{
+    cell &start = tbl[((__uint32)(XADDR(key)) & templ) >> right_zero_bits];
+
+    if (start.is_present)
+    {
+        if (start.key == key)
+        {
+            if (start.next == NULL)
+            {
+                start.key.clear();
+                start.is_present = false;
+            }
+            else
+            {
+                start.key = start.next->key;
+                start.val = start.next->val;  /* (A) */ 
+                add_cell *p = start.next;
+                start.next = start.next->next;
+                delete p;
+                start.is_present = true;
+            }
+            --num;
+            return 0;
+        }
+        else
+        {
+            if (start.next == NULL) return 1;
+
+            if (start.next->key == key)
+            {
+                add_cell * p = start.next;
+                start.next = start.next->next; /* (B) */ 
+                delete p;
+                --num;
+                return 0;
+            }
+
+            add_cell * pred = start.next;
+            add_cell * cur = start.next->next;
+
+            for (; cur != NULL; cur = cur->next, pred = pred->next)
+            {
+                if (cur->key == key)
+                {
+                    pred->next = cur->next; /* (C) */  
+                    delete cur;
+                    --num;
+                    return 0;
+                }
+            }
+            return 1;
+            
+        }
+    }
+    else return 1;
+
+    --num;
+    return 0;
+}
+
+
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+int XptrHash<T, middle_significan_bits, right_zero_bits>::find_remove(xptr key, T &val)
+{
+    cell &start = tbl[((__uint32)(XADDR(key)) & templ) >> right_zero_bits];
+
+    if (start.is_present)
+    {
+        if (start.key == key)
+        {
+            if (start.next == NULL)
+            {
+                val = start.val;
+                start.key.clear();
+                start.is_present = false;
+            }
+            else
+            {
+                val = start.val;
+                start.key = start.next->key;
+                start.val = start.next->val;
+                add_cell *p = start.next;
+                start.next = start.next->next;
+                delete p;
+                start.is_present = true;
+            }
+            --num;
+            return 0;
+        }
+        else
+        {
+            if (start.next == NULL) return 1;
+
+            if (start.next->key == key)
+            {
+                val = start.next->val;
+                add_cell * p = start.next;
+                start.next = start.next->next;
+                delete p;
+                --num;
+                return 0;
+            }
+
+            add_cell * pred = start.next;
+            add_cell * cur = start.next->next;
+
+            for (; cur != NULL; cur = cur->next, pred = pred->next)
+            {
+                if (cur->key == key)
+                {
+                    val = cur->val;
+                    pred->next = cur->next;
+                    delete cur;
+                    --num;
+                    return 0;
+                }
+            }
+            return 1;
+        }
+    }
+    else return 1;
+
+    --num;
+    return 0;
+}
+
+
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+int XptrHash<T, middle_significan_bits, right_zero_bits>::replace(xptr key, const T &new_val, T &old_val)
+{
+    cell &start = tbl[((__uint32)(XADDR(key)) & templ) >> right_zero_bits];
+    if (start.is_present)
+    {
+        if (start.key == key)
+        {
+            old_val = start.val;
+            start.val = new_val;
+            return 0;
+        }
+
+        add_cell * p = start.next;
+        for (; p != NULL; p = p->next)
+        {
+            if (p->key == key)
+            {
+                old_val = p->val;
+                p->val = new_val;
+                return 0;
+            }
+        }
+        return 1;
+    }
+    else return 1;
+
+    return 0;
+}
+
+template <class T, __uint32 middle_significan_bits, __uint32 right_zero_bits>
+void XptrHash<T, middle_significan_bits, right_zero_bits>::clear()
+{
+    if (num != 0)
+    {
+        add_cell *p = NULL, *tmp = NULL;
+    
+        for (__uint32 i = 0; i < ((__uint32)1 << middle_significan_bits); i++)
+        {
+            p = tbl[i].next;
+            while (p)
+            {
+                tmp = p;
+                p = tmp->next;
+                delete tmp;
+            }
+            tbl[i].key = XNULL;
+            tbl[i].next = NULL;
+            tbl[i].is_present = false;
+        }
+    
+        num = 0;
+    }
+}
+
+#endif
+