Kernel.h

Go to the documentation of this file.

//=============================================================================
//  Computational Process Networks class library
//  Copyright (C) 1997-2006  Gregory E. Allen and The University of Texas
//
//  This library is free software; you can redistribute it and/or modify it
//  under the terms of the GNU Library General Public License as published
//  by the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Library General Public License for more details.
//
//  The GNU Public License is available in the file LICENSE, or you
//  can write to the Free Software Foundation, Inc., 59 Temple Place -
//  Suite 330, Boston, MA 02111-1307, USA, or you can find it on the
//  World Wide Web at http://www.fsf.org.
//=============================================================================
#ifndef CPN_KERNEL_H
#define CPN_KERNEL_H
#pragma once
#include <cpn/common.h>
#include <cpn/KernelAttr.h>
#include <cpn/NodeAttr.h>
#include <cpn/QueueAttr.h>
#include <cpn/bits/KernelBase.h>
#include <cpn/threading/ReentrantLock.h>
#include <cpn/threading/StatusHandler.h>
#include <cpn/utils/Logger.h>
#include <cpn/Context.h>
#include <cpn/bits/NodeLoader.h>
#include <string>
#include <map>
#include <vector>

class Pthread;

namespace CPN {

    class CPN_API Kernel : public KernelBase {
        enum KernelStatus_t {
            INITIALIZED, RUNNING, TERMINATE, DONE
        };
    public:

        Kernel(const KernelAttr &kattr);
        ~Kernel();

        void Wait();

        void Terminate();

        bool IsTerminated();

        void CheckTerminated();

        Key_t CreateNode(const NodeAttr &attr);
        Key_t CreateNode(const std::string &name_, const std::string &nodetype_) {
            return CreateNode(NodeAttr(name_,nodetype_));
        }

        template<typename Function>
        Key_t CreateFunctionNode(const std::string &nodename, Function func);
        template<typename Function, typename Argument1>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1);
        template<typename Function, typename Argument1, typename Argument2>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1, Argument2 arg2);
        template<typename Function, typename Argument1, typename Argument2, typename Argument3>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1, Argument2 arg2, Argument3 arg3);
        template<typename Function, typename Argument1, typename Argument2, typename Argument3, typename Argument4>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1, Argument2 arg2, Argument3 arg3, Argument4 arg4);
        template<typename Function, typename Argument1, typename Argument2, typename Argument3, typename Argument4, typename Argument5>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1, Argument2 arg2, Argument3 arg3, Argument4 arg4, Argument5 arg5);
        template<typename Function, typename Argument1, typename Argument2, typename Argument3, typename Argument4, typename Argument5, typename Argument6>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1, Argument2 arg2, Argument3 arg3, Argument4 arg4, Argument5 arg5, Argument6 arg6);
        template<typename Function, typename Argument1, typename Argument2, typename Argument3, typename Argument4, typename Argument5, typename Argument6, typename Argument7>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1, Argument2 arg2, Argument3 arg3, Argument4 arg4, Argument5 arg5, Argument6 arg6, Argument7 arg7);
        template<typename Function, typename Argument1, typename Argument2, typename Argument3, typename Argument4, typename Argument5, typename Argument6, typename Argument7, typename Argument8>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1, Argument2 arg2, Argument3 arg3, Argument4 arg4, Argument5 arg5, Argument6 arg6, Argument7 arg7, Argument8 arg8);
        template<typename Function, typename Argument1, typename Argument2, typename Argument3, typename Argument4, typename Argument5, typename Argument6, typename Argument7, typename Argument8, typename Argument9>
        Key_t CreateFunctionNode(const std::string &nodename, Function func, Argument1 arg1, Argument2 arg2, Argument3 arg3, Argument4 arg4, Argument5 arg5, Argument6 arg6, Argument7 arg7, Argument8 arg8, Argument9 arg9);
        void CreateExternalReader(const std::string &name);
        void CreateExternalWriter(const std::string &name);

        shared_ptr<QueueWriter> GetExternalOQueue(const std::string &name);

        shared_ptr<QueueReader> GetExternalIQueue(const std::string &name);

        void DestroyExternalEndpoint(const std::string &name);

        void WaitForNode(const std::string &nodename);
        void WaitForAllNodes();
        void WaitForNodeStart(const std::string &nodename);

        void CreateQueue(const QueueAttr &attr);

        LoggerOutput *GetLogger() { return &logger; }

        const std::string GetName() const { return kernelname; }

        Key_t GetKey() const { return kernelkey; }

        shared_ptr<Context> GetContext() const { return context; }

        void NodeTerminated(Key_t key);

        void NotifyTerminate();
        void RemoteCreateWriter(SimpleQueueAttr attr);
        void RemoteCreateReader(SimpleQueueAttr attr);
        void RemoteCreateQueue(SimpleQueueAttr attr);
        void RemoteCreateNode(NodeAttr attr);
        void LoadSharedLib(const std::string &libname) { nodeloader.LoadSharedLib(libname); }

        void LoadNodeList(const std::string &filename) { nodeloader.LoadNodeList(filename); }

        void SearchDirectory(const std::string &dirname) { nodeloader.SearchDirectory(dirname); }

        NodeFactory *GetNodeFactory(const std::string &nodetype) { return nodeloader.GetFactory(nodetype); }

        void RegisterNodeFactory(shared_ptr<NodeFactory> factory) { nodeloader.RegisterFactory(factory); }

        bool UseD4R();
        bool UseD4R(bool u);

        bool GrowQueueMaxThreshold();
        bool GrowQueueMaxThreshold(bool grow);

        bool SwallowBrokenQueueExceptions();
        bool SwallowBrokenQueueExceptions(bool sbqe);

        unsigned CalculateGrowSize(unsigned currentsize, unsigned request) {
            return context->CalculateGrowSize(currentsize, request);
        }

    private:
        // Not copyable
        Kernel(const Kernel&);
        Kernel &operator=(const Kernel&);

        void CreateExternalEndpoint(const std::string &name, bool iswriter);

        void CreateReaderEndpoint(const SimpleQueueAttr &attr);
        void CreateWriterEndpoint(const SimpleQueueAttr &attr);
        void CreateLocalQueue(const SimpleQueueAttr &attr);
        void InternalCreateNode(NodeAttr &nodeattr);
        void ClearGarbage();

        void *EntryPoint();

        void SendWakeup();

        // Function to be called from gdb
        void LogState();

        Sync::StatusHandler<KernelStatus_t> status;

        // Read only after construction or contain own synchronization,
        // no explicit synchronization required
        auto_ptr<Pthread> thread;
        const std::string kernelname;
        Key_t kernelkey;
        Logger logger;
        shared_ptr<Context> context;
        auto_ptr<ConnectionServer> server;
        auto_ptr<RemoteQueueHolder> remotequeueholder;
        bool useremote;
        NodeLoader nodeloader;

        typedef std::map<Key_t, shared_ptr<PseudoNode> > NodeMap;
        typedef std::vector< shared_ptr<PseudoNode> > NodeList;

        // nodelock serializes access to nodemap
        Sync::ReentrantLock nodelock;
        Sync::ReentrantCondition nodecond;
        bool nodecond_signal;
        NodeMap nodemap;
        Sync::ReentrantLock garbagelock;
        NodeList garbagenodes;

        Sync::ReentrantLock datalock;
        bool useD4R;
        bool swallowbrokenqueue;
        bool growmaxthresh;
    };
}

#include <cpn/bits/FunctionNode.h>

#endif