---

dataserver.h

Go to the documentation of this file.

//**************************************************************************
#ifndef _DATASERVER_H_
#define _DATASERVER_H_
//**************************************************************************
#include "remotesocket.h"
#include "keyinfo.h"
#ifdef __GNUG__
#include <vector.h>
#include <map.h>
#else
#include <vector>
#include <map>
#endif
#include <map>
#include <string>
#include <signal.h>
//**************************************************************************
#ifndef _THREAD_SAFE
#define _THREAD_SAFE
#endif
//**************************************************************************
typedef map <char *, int> Hash_Table;
//typedef map <string, int> Hash_Table;
//**************************************************************************
class DataServer;
class DataServerChildThread;
class DataServerMainThread;
typedef struct { 
        int ID; 
        int isRunning;
        DataServer *server; 
        DataServerChildThread *th;
        RemoteSocket *client;
        } ChildThreadStruct;
//**************************************************************************
class DataServer : protected RemoteSocket
{
private:
        friend class DataServerMainThread;
        friend class DataServerChildThread;

        int p_run_flag;
        int p_serverID;
        DataServerMainThread *Parent;
        vector<ChildThreadStruct *> child;
        Semaphore p_lock;
        Hash_Table p_hash_table;
        int start_time;

        int Terminate();
        int Finalize();
        int NumPendingThreads();
        int UpdateKeyTable();
        int Register() {int temp; return Register("", NULL, temp, true); }
        int Register(char *keyword, RemoteSocket *client, int &error_flag, bool register_flag = false);
        int RegisterExternal(char *keyword, RemoteSocket *client, int &error_flag, bool register_flag = false);
        int MapKey(char *key);
        Semaphore *Lock();
        Semaphore *Lock(char *key);
        // For executing the threads
        void RunThread(int clientID);
        int ClearLocks();

        virtual int RegisterInternal(char *keyword, RemoteSocket *client, int &error_flag, bool register_flag = false) { return 0; }

        template <class Etype>
        int Register_Variable_Internal(RemoteSocket *C, int &flag, char *inpkey, char *key, char *perm, Etype &data);
        template <class Etype>
        int Register_Structure_Internal(RemoteSocket *C, int &flag, char *inpkey, char *key, char *perm, Etype &data);

protected:
        KeyTable *keytable;
        void (*callback)(char*);
        virtual bool isMaster()
                { return true; }
        virtual void BroadcastData(void *var, int size) { }
        template <class Etype>
                void BroadcastVariable(Etype *var, int n = 1)
                        { BroadcastData(var, sizeof(Etype)*n); }
        virtual void GetKeyword(RemoteSocket *C, char *key)
                { C->RecvLine(key); }
        virtual int AcceptClient();
        virtual bool isRunningMPI()
                { return false; }
        int Synchronize(char *filename = NULL);
        int RegisterKey(char *key, DataType desc, char *type, int elem_size, int num_elems, char *perm, void *ptr = NULL);

        template <class Etype>
        int Register_Variable(RemoteSocket *C, int &flag, bool register_flag, char *inpkey, char *key, char *perm, Etype &data);
        template <class Etype>
        int Register_Structure(RemoteSocket *C, int &flag, bool register_flag, char *inpkey, char *key, char *perm, Etype &data);
        template <class Etype>
        int Register_Static_Array(RemoteSocket *C, int &flag, bool register_flag, char *inpkey, char *key, char *perm, void *data, Etype &element, int totsize, int dim);
        template <class Etype>
        int Register_Dynamic_1D_Array(RemoteSocket *C, int &flag, bool register_flag, char *inpkey, char *key, char *perm, Etype *data, int &n1);
        template <class Etype>
        int Register_Dynamic_2D_Array(RemoteSocket *C, int &flag, bool register_flag, char *inpkey, char *key, char *perm, Etype **data, int &n1, int &n2);
        template <class Etype>
        int Register_Dynamic_3D_Array(RemoteSocket *C, int &flag, bool register_flag, char *inpkey, char *key, char *perm, Etype ***data, int &n1, int &n2, int &n3);
        template <class Etype>
        int Register_Dynamic_4D_Array(RemoteSocket *C, int &flag, bool register_flag, char *inpkey, char *key, char *perm, Etype ****data, int &n1, int &n2, int &n3, int &n4);

public:
        DataServer();

        DataServer(int port);

        int Start(int port = 4096);

        ~DataServer();

        void RegisterCallback(void (*cb)(char*));

        void RegisterCallback(char *key, void (*cb)(void*), void *data)
                { keytable->RegisterCallback(key, cb, data); }

        int isRunning();

        int Stop();

        int Wait();

        int Post();

        int Wait(char *keyword);

        int Post(char *keyword);

        int SetDirty(char *keyword);

        int IsDirty(int change = 1);

        int IsDirty(char *keyword, int change = 1);

        int IsDirtyID(int id, int change = 1);

        void PrintDirty(ostream &out = cout, int change = 0);

        int NumKeys();

        char *Key(int i);

        char *GetValue(char *keyword);

        char *GetValue(int i);

        double BytesSent() { return TCPSocket::BytesSent(); }

        double BytesRecd() { return TCPSocket::BytesRecd(); }

        int SendTime() { return TCPSocket::SendTime(); }

        int RecvTime() { return TCPSocket::RecvTime(); }

        double SendRate() { return 8.0*BytesSent()/(1000.0*SendTime()); }

        double RecvRate() { return 8.0*BytesRecd()/(1000.0*RecvTime()); }

};
//**************************************************************************
inline int DataServer::NumKeys()
{
return keytable->n;
}
//**************************************************************************
inline char *DataServer::Key(int i)
{
return keytable->key[i].key;
}
//**************************************************************************
inline int DataServer::isRunning()
{
return p_run_flag;
}
//**************************************************************************
inline Semaphore *DataServer::Lock()
{
return &p_lock;
}
//**************************************************************************
inline Semaphore *DataServer::Lock(char *key)
{
int id = MapKey(key);
#ifdef ANIDEBUG
cout << "DataServer::Lock: Looking for semaphore on key \"" << key << "\"." << endl << flush;
#endif

return keytable->key[id].sem;
}
//**************************************************************************
inline int DataServer::Wait()
{
Lock()->Wait();
return 0;
}
//**************************************************************************
inline int DataServer::Post()
{
Lock()->Post();
return 0;
}
//**************************************************************************
inline int DataServer::Wait(char *key)
{
Lock(key)->Wait();
return 0;
}
//**************************************************************************
inline int DataServer::Post(char *key)
{
Lock(key)->Post();
return 0;
}
//**************************************************************************
inline int DataServer::MapKey(char *key)
{
static char prevkey[40] = "";
static int prevID = -1;

// Caching of last key
if (strcmp(prevkey, key) == 0)
        return prevID;

Hash_Table::const_iterator i = p_hash_table.find(key);

if (i == p_hash_table.end())
        {
         // Double check due to STL hashing errors leading to
         // the key not being found inspite of being present.
         for (Hash_Table::const_iterator h = p_hash_table.begin(); h != p_hash_table.end(); h++)
                if (strcmp(h->first, key) == 0)
                        {
                         cout << "STL hashing error encountered!!" << endl << flush;
                         return h->second;
                        }
         cout << "DataServer::MapKey: Error! Unidentified keyword \"" << key << "\"." << endl << flush;
         Finalize();
         exit(-1);
        }

strcpy(prevkey, key);
prevID = i->second;
return i->second;
}
//**************************************************************************
inline int DataServer::SetDirty(char *key)
{
int id = MapKey(key);
#ifdef ANIDEBUG
cout << "DataServer::SetDirty: Setting Dirty for key \"" << key << "\"." << endl << flush;
#endif

keytable->key[id].is_dirty = 1;

return 0;
}
//**************************************************************************
inline int DataServer::IsDirtyID(int id, int change)
{
int flag = keytable->key[id].is_dirty;
if (change)
        keytable->key[id].is_dirty = 0;

return flag;
}
//**************************************************************************
inline int DataServer::IsDirty(char *key, int change)
{
int id = MapKey(key);
int flag = keytable->key[id].is_dirty;
if (change)
        keytable->key[id].is_dirty = 0;

return flag;
}
//**************************************************************************
inline int DataServer::IsDirty(int change)
{
int count = 0;
for (int i = 0; i < keytable->n; i++)
        {
         count += keytable->key[i].is_dirty;
         if (change)
                keytable->key[i].is_dirty = 0;
        }
return count;
}
//**************************************************************************
#include "dataserver_register_orig.h"
#include "dataserver_register.h"
//**************************************************************************
#endif  // _DATASERVER_H_
//**************************************************************************

---