#include <Kernel.h>

Inheritance diagram for CPN::Kernel:

Collaboration diagram for CPN::Kernel:

Public Member Functions
	Kernel (const KernelAttr &kattr)

	~Kernel ()

void	Wait ()

void	Terminate ()

bool	IsTerminated ()

void	CheckTerminated ()
	Convenience method that checks IsTerminated and if so throws a ShutdownException. More...

Key_t	CreateNode (const NodeAttr &attr)

Key_t	CreateNode (const std::string &name_, const std::string &nodetype_)
	Same as CreateNode that takes a NodeAttr except only the required parameters are set. More...

void	CreateExternalReader (const std::string &name)
	Create an external reader. More...

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 ()
	Waits until there are no running nodes. More...

void	WaitForNodeStart (const std::string &nodename)
	Wait for the given node to start. More...

void	CreateQueue (const QueueAttr &attr)
	Create a new queue. More...

LoggerOutput *	GetLogger ()

const std::string	GetName () const

Key_t	GetKey () const

shared_ptr< Context >	GetContext () const

void	NodeTerminated (Key_t key)
	Called by the node in the cleanup routine. TO BE CALLED ONLY BY THE CPN INTERNALS. More...

void	LoadSharedLib (const std::string &libname)
	Attempts to load the given dynamic library and make the symbols inside available to be searched for node types. The library will be unloaded on distruction. More...

void	LoadNodeList (const std::string &filename)

void	SearchDirectory (const std::string &dirname)

NodeFactory *	GetNodeFactory (const std::string &nodetype)
	Return a pointer to the node factory that produces the given node type. May load a shared library to find the node factory. More...

void	RegisterNodeFactory (shared_ptr< NodeFactory > factory)
	A function that lets others register node factories. More...

unsigned	CalculateGrowSize (unsigned currentsize, unsigned request)
	Calculate the new queue size when a queue needs to grow. More...


template<typename Function >
Key_t	CreateFunctionNode (const std::string &nodename, Function func)
	Instantiating a function node. More...

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	NotifyTerminate ()

void	RemoteCreateWriter (SimpleQueueAttr attr)

void	RemoteCreateReader (SimpleQueueAttr attr)

void	RemoteCreateQueue (SimpleQueueAttr attr)

void	RemoteCreateNode (NodeAttr attr)


bool	UseD4R ()
	Whether or not D4R should be used. More...

bool	UseD4R (bool u)

bool	GrowQueueMaxThreshold ()
	Whether the queue should grow when a threshold larger than the current max threshold is requested. More...

bool	GrowQueueMaxThreshold (bool grow)

bool	SwallowBrokenQueueExceptions ()
	Whether the node should by default swallow the broken queue exceptions or let them propigate as an error. More...

bool	SwallowBrokenQueueExceptions (bool sbqe)

Private Types
enum	KernelStatus_t { INITIALIZED, RUNNING, TERMINATE, DONE }

typedef std::map< Key_t, shared_ptr< PseudoNode > >	NodeMap

typedef std::vector < shared_ptr< PseudoNode > >	NodeList

Private Member Functions
	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 ()

void	LogState ()

Private Attributes
Sync::StatusHandler < KernelStatus_t >	status

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

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

Detailed Description

The Kernel declaration.

The purpose of the kernel object is to keep track of all the queues and nodes on a particular kernel, ensure that they are instantiated and destroyed correctly and to provide a unified interface to the user of the process network.

Definition at line 55 of file Kernel.h.

Member Typedef Documentation

typedef std::vector< shared_ptr<PseudoNode> > CPN::Kernel::NodeList

private

Definition at line 356 of file Kernel.h.

typedef std::map<Key_t, shared_ptr<PseudoNode> > CPN::Kernel::NodeMap

private

Definition at line 355 of file Kernel.h.

Member Enumeration Documentation

enum CPN::Kernel::KernelStatus_t

private

Enumerator
INITIALIZED
RUNNING
TERMINATE
DONE

Definition at line 56 of file Kernel.h.

                             {
             INITIALIZED, RUNNING, TERMINATE, DONE
         };

Constructor & Destructor Documentation

CPN::Kernel::Kernel ( const KernelAttr & kattr )

Construct a new kernel object with the given attributes. The Kernel starts processing immediately.

Definition at line 53 of file Kernel.cc.

References Sync::StatusHandler< Status_t >::CompareAndWait(), context, SocketAddress::CreateIP(), CreatePthreadFunctional(), EntryPoint(), FUNCBEGIN, SocketAddress::GetHostName(), CPN::KernelAttr::GetHostName(), CPN::KernelAttr::GetNodeLists(), CPN::KernelAttr::GetNodeSearchPaths(), SocketAddress::GetServName(), CPN::KernelAttr::GetServName(), CPN::KernelAttr::GetSharedLibs(), Logger::Info(), INITIALIZED, kernelkey, kernelname, CPN::NodeLoader::LoadNodeList(), CPN::NodeLoader::LoadSharedLib(), CPN::Context::Local(), logger, Logger::LogLevel(), Logger::Name(), nodeloader, Logger::Output(), remotequeueholder, CPN::NodeLoader::SearchDirectory(), server, status, thread, and useremote.

         : status(INITIALIZED),
         kernelname(kattr.GetName()),
         kernelkey(0),
         context(kattr.GetContext()),
         useremote(kattr.GetRemoteEnabled()),
         nodecond_signal(false),
         useD4R(kattr.UseD4R()),
         swallowbrokenqueue(kattr.SwallowBrokenQueueExceptions()),
         growmaxthresh(kattr.GrowQueueMaxThreshold())
     {
         FUNCBEGIN;
 #ifdef CPN_NODELIBDIR
         try {
             nodeloader.SearchDirectory(CPN_NODELIBDIR);
         } catch (const ErrnoException &e) {}
 #endif
         nodeloader.SearchDirectory(kattr.GetNodeSearchPaths());
         nodeloader.LoadSharedLib(kattr.GetSharedLibs());
         nodeloader.LoadNodeList(kattr.GetNodeLists());
         thread.reset(CreatePthreadFunctional(this, &Kernel::EntryPoint));
         if (!context) {
             context = Context::Local();
         }
         if (context->RequireRemote()) {
             useremote = true;
         }
         logger.Output(context.get());
         logger.LogLevel(context->LogLevel());
         logger.Name(kernelname);
 
         if (useremote) {
             SockAddrList addrlist = SocketAddress::CreateIP(kattr.GetHostName(),
                     kattr.GetServName());
             server.reset(new ConnectionServer(addrlist, context));
 
             SocketAddress addr = server->GetAddress();
             kernelkey = context->SetupKernel(kernelname, addr.GetHostName(), addr.GetServName(), this);
             remotequeueholder.reset(new RemoteQueueHolder());
 
             logger.Info("New kernel, listening on %s:%s", addr.GetHostName().c_str(), addr.GetServName().c_str());
         } else {
             kernelkey = context->SetupKernel(kernelname, this);
             logger.Info("New kernel");
         }
         // Start up and don't finish until actually started.
         thread->Start();
         status.CompareAndWait(INITIALIZED);
     }

Here is the call graph for this function:

CPN::Kernel::~Kernel ( )

Definition at line 103 of file Kernel.cc.

References FUNCBEGIN, FUNCEND, Terminate(), thread, and Wait().

                     {
         FUNCBEGIN;
         Terminate();
         Wait();
         thread->Join();
         FUNCEND;
     }

Here is the call graph for this function:

CPN::Kernel::Kernel ( const Kernel & )

private

Member Function Documentation

unsigned CPN::Kernel::CalculateGrowSize	(	unsigned	currentsize,
		unsigned	request
	)

inlinevirtual

Calculate the new queue size when a queue needs to grow.

Returns: the new queue size

Implements CPN::KernelBase.

Definition at line 317 of file Kernel.h.

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

void CPN::Kernel::CheckTerminated ( )

virtual

Convenience method that checks IsTerminated and if so throws a ShutdownException.

Exceptions

ShutdownException

Implements CPN::KernelBase.

Definition at line 128 of file Kernel.cc.

References context.

                                  {
         context->CheckTerminated();
     }

void CPN::Kernel::ClearGarbage ( )

private

Definition at line 516 of file Kernel.cc.

References FUNCBEGIN, garbagelock, and garbagenodes.

Referenced by EntryPoint().

                               {
         Sync::AutoReentrantLock arlock(garbagelock);
         FUNCBEGIN;
         while (!garbagenodes.empty()) {
             garbagenodes.back()->Shutdown();
             garbagenodes.pop_back();
         }
     }

Here is the caller graph for this function:

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

private

Definition at line 186 of file Kernel.cc.

References context, kernelkey, nodelock, nodemap, and AutoLock< Lockable >::Unlock().

Referenced by CreateExternalReader(), and CreateExternalWriter().

                                                                             {
         Key_t nodekey = context->CreateNodeKey(kernelkey, name);
         shared_ptr<PseudoNode> pnode;
         pnode.reset(new ExternalEndpoint(name, nodekey, context, iswriter));
         Sync::AutoReentrantLock arlock(nodelock);
         nodemap.insert(std::make_pair(nodekey, pnode));
         arlock.Unlock();
         context->SignalNodeStart(nodekey);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::Kernel::CreateExternalReader ( const std::string & name )

Create an external reader.

A external reader is a handle for applications to use outside of the network to input and output data

Note that an external reader can only be used on the kernel it is created on.

Implementation detail: External endpoints create a node internally with the same name. This means that they can be waited on with WaitForNodeStart and WaitForNode. Also, WaitForAllNodes will not return until all external endpoints have been destroyed. Additionally, external endpoint names must be unique across the network and cannot share the same name as any node.

Parameters

name	the name of the reader

Definition at line 178 of file Kernel.cc.

References CreateExternalEndpoint().

                                                            {
         CreateExternalEndpoint(name, false);
     }

Here is the call graph for this function:

void CPN::Kernel::CreateExternalWriter ( const std::string & name )

Dual of CreateExternalReader

Definition at line 182 of file Kernel.cc.

References CreateExternalEndpoint().

                                                            {
         CreateExternalEndpoint(name, true);
     }

Here is the call graph for this function:

template<typename Function >

Key_t CPN::Kernel::CreateFunctionNode	(	const std::string &	nodename,
		Function	func
	)

Instantiating a function node.

The idea of a function node is a simple function with minimal state. A node is created and then the function is called with the given parameters.

This list of prototypes was generated by FunctionNode.py

template<typename Function , typename Argument1 >

Key_t CPN::Kernel::CreateFunctionNode	(	const std::string &	nodename,
		Function	func,
		Argument1	arg1
	)

template<typename Function , typename Argument1 , typename Argument2 >

Key_t CPN::Kernel::CreateFunctionNode	(	const std::string &	nodename,
		Function	func,
		Argument1	arg1,
		Argument2	arg2
	)

template<typename Function , typename Argument1 , typename Argument2 , typename Argument3 >

Key_t CPN::Kernel::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 CPN::Kernel::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 CPN::Kernel::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 CPN::Kernel::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 CPN::Kernel::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 CPN::Kernel::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 CPN::Kernel::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 CPN::Kernel::CreateLocalQueue ( const SimpleQueueAttr & attr )

private

Definition at line 457 of file Kernel.cc.

References CPN::SimpleQueueAttr::GetHint(), CPN::SimpleQueueAttr::GetReaderNodeKey(), CPN::SimpleQueueAttr::GetWriterNodeKey(), nodelock, nodemap, CPN::ParseQueueHintForMBS(), and CPN::QUEUEHINT_DEFAULT.

Referenced by CreateQueue(), and RemoteCreateQueue().

                                                              {
         QueueHintStatus hint = ParseQueueHintForMBS(attr.GetHint());
         shared_ptr<QueueBase> queue;
         queue = shared_ptr<QueueBase>(new ThresholdQueue(this, attr, hint != QUEUEHINT_DEFAULT));
 
         Sync::AutoReentrantLock arlock(nodelock);
         NodeMap::iterator readentry = nodemap.find(attr.GetReaderNodeKey());
         shared_ptr<PseudoNode> readnode;
         if (readentry != nodemap.end()) {
             readnode = readentry->second;
         }
 
         NodeMap::iterator writeentry = nodemap.find(attr.GetWriterNodeKey());
         shared_ptr<PseudoNode> writenode;
         if (writeentry != nodemap.end()) {
             writenode = writeentry->second;
         }
         arlock.Unlock();
 
         if (writenode) { writenode->CreateWriter(queue); }
         else { queue->ShutdownWriter(); }
         if (readnode) { readnode->CreateReader(queue); }
         else { queue->ShutdownReader(); }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::Kernel::CreateNode ( const NodeAttr & attr )

Create a new node.

Parameters

attr	The NodeAttr that describes the new node to create.

Returns: the new node's key

Exceptions

KernelShutdownException if Wait completed or Terminate has been called.

Definition at line 139 of file Kernel.cc.

References context, FUNCBEGIN, CPN::NodeAttr::GetKernel(), CPN::NodeAttr::GetKernelKey(), CPN::NodeAttr::GetName(), InternalCreateNode(), kernelkey, CPN::NodeAttr::SetKernelKey(), and CPN::NodeAttr::SetKey().

Referenced by CPN::VariantCPNLoader::LoadNode().

                                                  {
         FUNCBEGIN;
 
         NodeAttr nodeattr = attr;
 
         if (nodeattr.GetKernelKey() == 0) {
             Key_t key = 0;
             if (nodeattr.GetKernel().empty()) {
                 key = kernelkey;
             } else {
                 key = context->WaitForKernelStart(nodeattr.GetKernel());
             }
             nodeattr.SetKernelKey(key);
         }
         Key_t nodekey = context->CreateNodeKey(nodeattr.GetKernelKey(), nodeattr.GetName());
         nodeattr.SetKey(nodekey);
 
         // check the kernel the node should go on and send
         // to that particular kernel
         if (nodeattr.GetKernelKey() == kernelkey) {
             InternalCreateNode(nodeattr);
         } else {
             context->SendCreateNode(nodeattr.GetKernelKey(), nodeattr);
         }
         return nodekey;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::Kernel::CreateNode	(	const std::string &	name_,
		const std::string &	nodetype_
	)

inline

Same as CreateNode that takes a NodeAttr except only the required parameters are set.

Parameters

name	the name of the node
nodetype	the node type name

Returns: the new node's key

Definition at line 107 of file Kernel.h.

                                                                              {
             return CreateNode(NodeAttr(name_,nodetype_));
         }

void CPN::Kernel::CreateQueue ( const QueueAttr & attr )

Create a new queue.

Note that the nodes for the queue must already exist.

Parameters

attr	the attribute to use to create the queu

See Also: QueueAttr

Definition at line 251 of file Kernel.cc.

Referenced by CPN::VariantCPNLoader::LoadQueue().

                                                    {
         FUNCBEGIN;
         // Normalize the QueueAttr into a SimpleQueueAttr
         // This gets rid of the names and translates to IDs
         SimpleQueueAttr attr = qattr;
         if (attr.GetReaderKey() == 0) {
             if (attr.GetReaderNodeKey() == 0) {
                 if (qattr.GetReaderNode().empty()) {
                     throw std::invalid_argument(
                             "The reader side must be specified with the reader key"
                             " or the reader name and node key or the reader name and"
                             " node name.");
                 }
                 attr.SetReaderNodeKey(context->WaitForNodeStart(qattr.GetReaderNode()));
             }
             if (qattr.GetReaderPort().empty()) {
                 throw std::invalid_argument("Ether the port key or port name must be specified.");
             }
             attr.SetReaderKey(context->GetCreateReaderKey(attr.GetReaderNodeKey(),
                         qattr.GetReaderPort()));
         } else if (attr.GetReaderNodeKey() == 0) {
             attr.SetReaderNodeKey(context->GetReaderNode(attr.GetReaderKey()));
         }
 
         if (attr.GetWriterKey() == 0) {
             if (attr.GetWriterNodeKey() == 0) {
                 if (qattr.GetWriterNode().empty()) {
                     throw std::invalid_argument(
                             "The writer side must be specified with the writer key"
                             " or the writer name and node key or the writer name and"
                             " node name.");
                 }
                 attr.SetWriterNodeKey(context->WaitForNodeStart(qattr.GetWriterNode()));
             }
             if (qattr.GetWriterPort().empty()) {
                 throw std::invalid_argument("Ether the port key or port name must be specified.");
             }
             attr.SetWriterKey(context->GetCreateWriterKey(attr.GetWriterNodeKey(),
                         qattr.GetWriterPort()));
         } else if (attr.GetWriterNodeKey() == 0) {
             attr.SetWriterNodeKey(context->GetWriterNode(attr.GetWriterKey()));
         }
 
         context->ConnectEndpoints(attr.GetWriterKey(), attr.GetReaderKey(), qattr.GetName());
 
         Key_t readerkernel = context->GetNodeKernel(attr.GetReaderNodeKey());
         Key_t writerkernel = context->GetNodeKernel(attr.GetWriterNodeKey());
 
         if (readerkernel == writerkernel) {
             if (readerkernel == kernelkey) {
                 CreateLocalQueue(attr);
             } else {
                 ASSERT(useremote, "Cannot create remote queue without enabling remote operations.");
                 // Send a message to the other kernel to create a local queue
                 context->SendCreateQueue(readerkernel, attr);
             }
         } else if (readerkernel == kernelkey) {
             ASSERT(useremote, "Cannot create remote queue without enabling remote operations.");
             // Create the reader end here and queue up a message
             // to the writer kernel that they need to create an endpoint
             CreateReaderEndpoint(attr);
             context->SendCreateWriter(writerkernel, attr);
         } else if (writerkernel == kernelkey) {
             ASSERT(useremote, "Cannot create remote queue without enabling remote operations.");
             // Create the writer end here and queue up a message to
             // the reader kernel that they need to create an endpoint
             CreateWriterEndpoint(attr);
             context->SendCreateReader(readerkernel, attr);
         } else {
             ASSERT(useremote, "Cannot create remote queue without enabling remote operations.");
             // Queue up a message to both the reader and writer kernel
             // to create endpoints
             context->SendCreateWriter(writerkernel, attr);
             context->SendCreateReader(readerkernel, attr);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::Kernel::CreateReaderEndpoint ( const SimpleQueueAttr & attr )

private

Definition at line 363 of file Kernel.cc.

References ASSERT, CPN::SimpleQueueAttr::GetHint(), CPN::SimpleQueueAttr::GetReaderNodeKey(), nodelock, nodemap, CPN::ParseQueueHintForMBS(), CPN::QUEUEHINT_DEFAULT, CPN::QUEUEHINT_RDMA, CPN::RemoteQueue::READ, remotequeueholder, server, AutoLock< Lockable >::Unlock(), and useremote.

Referenced by CreateQueue(), and RemoteCreateReader().

                                                                  {
         ASSERT(useremote, "Cannot create remote queue without enabling remote operations.");
 
         QueueHintStatus hint = ParseQueueHintForMBS(attr.GetHint());
         shared_ptr<RemoteQueueBase> endp;
         shared_ptr<QueueBase> queue;
 #if ENABLE_RDMA
         if (hint == QUEUEHINT_RDMA) {
             shared_ptr<RDMAQueue> q = shared_ptr<RDMAQueue>(
                     new RDMAQueue(
                         this,
                         RDMAQueue::READ,
                         server.get(),
                         remotequeueholder.get(),
                         attr
                         )
                     );
             endp = q;
             queue = q;
         } else
 #endif
         {
             shared_ptr<RemoteQueue> q = shared_ptr<RemoteQueue>(
                     new RemoteQueue(
                         this,
                         RemoteQueue::READ,
                         server.get(),
                         remotequeueholder.get(),
                         attr,
                         hint != QUEUEHINT_DEFAULT
                         ));
             endp = q;
             queue = q;
         }
         Sync::AutoReentrantLock arlock(nodelock);
         NodeMap::iterator entry = nodemap.find(attr.GetReaderNodeKey());
         shared_ptr<PseudoNode> node = entry->second;
         if (entry != nodemap.end()) {
             node = entry->second;
         }
         arlock.Unlock();
         remotequeueholder->AddQueue(endp);
         endp->Start();
         if (node) { node->CreateReader(queue); }
         else { queue->ShutdownReader(); }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::Kernel::CreateWriterEndpoint ( const SimpleQueueAttr & attr )

private

Definition at line 410 of file Kernel.cc.

References ASSERT, CPN::SimpleQueueAttr::GetHint(), CPN::SimpleQueueAttr::GetWriterNodeKey(), nodelock, nodemap, CPN::ParseQueueHintForMBS(), CPN::QUEUEHINT_DEFAULT, CPN::QUEUEHINT_RDMA, remotequeueholder, server, AutoLock< Lockable >::Unlock(), useremote, and CPN::RemoteQueue::WRITE.

Referenced by CreateQueue(), and RemoteCreateWriter().

                                                                  {
         ASSERT(useremote, "Cannot create remote queue without enabling remote operations.");
 
         QueueHintStatus hint = ParseQueueHintForMBS(attr.GetHint());
         shared_ptr<RemoteQueueBase> endp;
         shared_ptr<QueueBase> queue;
 #if ENABLE_RDMA
         if (hint == QUEUEHINT_RDMA) {
             shared_ptr<RDMAQueue> q = shared_ptr<RDMAQueue>(
                     new RDMAQueue(
                         this,
                         RDMAQueue::WRITE,
                         server.get(),
                         remotequeueholder.get(),
                         attr
                         )
                     );
             endp = q;
             queue = q;
         } else
 #endif
         {
             shared_ptr<RemoteQueue> q = shared_ptr<RemoteQueue>(
                     new RemoteQueue(
                         this,
                         RemoteQueue::WRITE,
                         server.get(),
                         remotequeueholder.get(),
                         attr,
                         hint != QUEUEHINT_DEFAULT
                         ));
             endp = q;
             queue = q;
         }
         Sync::AutoReentrantLock arlock(nodelock);
         NodeMap::iterator entry = nodemap.find(attr.GetWriterNodeKey());
         shared_ptr<PseudoNode> node;
         if (entry != nodemap.end()) {
             node = entry->second;
         }
         arlock.Unlock();
         remotequeueholder->AddQueue(endp);
         endp->Start();
         if (node) { node->CreateWriter(queue); }
         else { queue->ShutdownWriter(); }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::Kernel::DestroyExternalEndpoint ( const std::string & name )

Clean up the external endpoint. Anybody waiting on it will then return. Note that calling WaitForAllNodes will block until all external endpoints have died or Terminate is called.

Definition at line 226 of file Kernel.cc.

References context, nodelock, nodemap, NodeTerminated(), and AutoLock< Lockable >::Unlock().

                                                               {
         Key_t key = context->GetNodeKey(name);
         Sync::AutoReentrantLock arlock(nodelock);
         NodeMap::iterator entry = nodemap.find(key);
         if (entry == nodemap.end() || !entry->second->IsPurePseudo()) {
             throw std::invalid_argument("Not a valid external endpoint.");
         }
         arlock.Unlock();
         NodeTerminated(key);
     }

Here is the call graph for this function:

void * CPN::Kernel::EntryPoint ( )

private

Definition at line 534 of file Kernel.cc.

References ClearGarbage(), Sync::StatusHandler< Status_t >::CompareAndPost(), context, DONE, FUNCBEGIN, FUNCEND, Sync::StatusHandler< Status_t >::Get(), INITIALIZED, kernelkey, AutoLock< Lockable >::Lock(), logger, nodecond, nodecond_signal, nodelock, nodemap, Sync::StatusHandler< Status_t >::Post(), remotequeueholder, RUNNING, server, status, AutoLock< Lockable >::Unlock(), useremote, Sync::ReentrantCondition::Wait(), and Logger::Warn().

Referenced by Kernel().

                              {
         FUNCBEGIN;
         status.CompareAndPost(INITIALIZED, RUNNING);
         try {
             context->SignalKernelStart(kernelkey);
             if (useremote) {
                 while (status.Get() == RUNNING) {
                     ClearGarbage();
                     remotequeueholder->Cleanup();
                     server->Poll();
                 }
             } else {
                 ClearGarbage();
                 Sync::AutoReentrantLock arlock(nodelock);
                 while (status.Get() == RUNNING) {
                     if (!nodecond_signal) {
                         nodecond.Wait(nodelock);
                         nodecond_signal = false;
                     }
                     arlock.Unlock();
                     ClearGarbage();
                     arlock.Lock();
                 }
             }
         } catch (const ShutdownException &e) {
             logger.Warn("Kernel forced shutdown");
         }
         if (useremote) {
             server->Close();
             remotequeueholder->Shutdown();
         }
         {
             Sync::AutoReentrantLock arlock(nodelock);
             NodeMap mapcopy = nodemap;
             arlock.Unlock();
             NodeMap::iterator nitr = mapcopy.begin();
             while (nitr != mapcopy.end()) {
                 (nitr++)->second->NotifyTerminate();
             }
             ClearGarbage();
             arlock.Lock();
             // Wait for all nodes to end
             while (!nodemap.empty()) {
                 if (!nodecond_signal) {
                     nodecond.Wait(nodelock);
                     nodecond_signal = false;
                 }
                 arlock.Unlock();
                 ClearGarbage();
                 arlock.Lock();
             }
         }
         ClearGarbage();
         context->SignalKernelEnd(kernelkey);
         status.Post(DONE);
         FUNCEND;
         return 0;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

shared_ptr<Context> CPN::Kernel::GetContext ( ) const

inlinevirtual

Returns: the context this kernel is using

Implements CPN::KernelBase.

Definition at line 227 of file Kernel.h.

Referenced by CPN::NodeBase::EntryPoint().

227 { return context; }

CPN::Kernel::context

shared_ptr< Context > context

Definition: Kernel.h:349

Here is the caller graph for this function:

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

Get a IQueue for the given external reader.

Parameters

name	the name of the reader

Returns: A pointer to an object that IQueue will accept.

Definition at line 211 of file Kernel.cc.

References context, nodelock, nodemap, and AutoLock< Lockable >::Unlock().

                                                                            {
         Key_t key = context->GetNodeKey(name);
         Sync::AutoReentrantLock arlock(nodelock);
         NodeMap::iterator entry = nodemap.find(key);
         if (entry == nodemap.end() || !entry->second->IsPurePseudo()) {
             throw std::invalid_argument("Not a valid external writer.");
         }
         shared_ptr<ExternalEndpoint> pnode = dynamic_pointer_cast<ExternalEndpoint>(entry->second);
         arlock.Unlock();
         if (pnode && !pnode->IsWriter()) {
             return pnode->GetIQueue(name);
         }
         throw std::invalid_argument("Not a valid external writer.");
     }

Here is the call graph for this function:

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

Get an OQueue for the given external writer.

Parameters

name	the name of the writer

Returns: A pointer to an object that oQueue will accept.

Definition at line 196 of file Kernel.cc.

References context, nodelock, nodemap, and AutoLock< Lockable >::Unlock().

                                                                            {
         Key_t key = context->GetNodeKey(name);
         Sync::AutoReentrantLock arlock(nodelock);
         NodeMap::iterator entry = nodemap.find(key);
         if (entry == nodemap.end() || !entry->second->IsPurePseudo()) {
             throw std::invalid_argument("Not a valid external reader.");
         }
         shared_ptr<ExternalEndpoint> pnode = dynamic_pointer_cast<ExternalEndpoint>(entry->second);
         arlock.Unlock();
         if (pnode && pnode->IsWriter()) {
             return pnode->GetOQueue(name);
         }
         throw std::invalid_argument("Not a valid external reader.");
     }

Here is the call graph for this function:

Key_t CPN::Kernel::GetKey ( ) const

inline

Returns: the unique key for this kernel

Definition at line 223 of file Kernel.h.

223 { return kernelkey; }

CPN::Kernel::kernelkey

Key_t kernelkey

Definition: Kernel.h:347

LoggerOutput* CPN::Kernel::GetLogger ( )

inline

Returns: A pointer to the logger instance used by the kernel.

Definition at line 214 of file Kernel.h.

214 { return &logger; }

CPN::Kernel::logger

Logger logger

Definition: Kernel.h:348

const std::string CPN::Kernel::GetName ( ) const

inline

Returns: the name of this kernel.

Definition at line 219 of file Kernel.h.

219 { return kernelname; }

CPN::Kernel::kernelname

const std::string kernelname

Definition: Kernel.h:346

NodeFactory* CPN::Kernel::GetNodeFactory ( const std::string & nodetype )

inline

Return a pointer to the node factory that produces the given node type. May load a shared library to find the node factory.

If there is no node factory available already, attempt to find a function named "cpninitnodetype" and call it to get the factory. If there is no function named this, then quiery the library loader for a library with the name nodetype then try again. If all this fails then throw a runtime_error exception.

Parameters

nodetype the type of the node

Returns: a node factory for the node type

Definition at line 276 of file Kernel.h.

Referenced by InternalCreateNode().

276 { return nodeloader.GetFactory(nodetype); }

CPN::Kernel::nodeloader

NodeLoader nodeloader

Definition: Kernel.h:353

CPN::NodeLoader::GetFactory

NodeFactory * GetFactory(const std::string &nodename)

Definition: NodeLoader.cc:99

Here is the caller graph for this function:

bool CPN::Kernel::GrowQueueMaxThreshold ( )

virtual

Whether the queue should grow when a threshold larger than the current max threshold is requested.

Returns: true or false (default true)

Implements CPN::KernelBase.

Definition at line 666 of file Kernel.cc.

References datalock, and growmaxthresh.

                                        {
         Sync::AutoReentrantLock al(datalock);
         return growmaxthresh;
     }

bool CPN::Kernel::GrowQueueMaxThreshold ( bool grow )

Definition at line 671 of file Kernel.cc.

References datalock, and growmaxthresh.

                                                 {
         Sync::AutoReentrantLock al(datalock);
         return growmaxthresh = grow;
     }

void CPN::Kernel::InternalCreateNode ( NodeAttr & nodeattr )

private

Definition at line 482 of file Kernel.cc.

References ASSERT, CPN::NodeFactory::Create(), FUNCBEGIN, Sync::StatusHandler< Status_t >::Get(), CPN::NodeAttr::GetKey(), GetNodeFactory(), CPN::NodeAttr::GetTypeName(), nodelock, nodemap, RUNNING, and status.

Referenced by CreateNode(), and RemoteCreateNode().

                                                       {
         Sync::AutoReentrantLock arlock(nodelock);
         FUNCBEGIN;
         ASSERT(status.Get() == RUNNING);
         NodeFactory *factory = GetNodeFactory(nodeattr.GetTypeName());
         if (!factory) {
             throw std::invalid_argument("No such node type " + nodeattr.GetTypeName());
         }
         shared_ptr<NodeBase> node = factory->Create(*this, nodeattr);
         nodemap.insert(std::make_pair(nodeattr.GetKey(), node));
         node->Start();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::Kernel::IsTerminated ( )

virtual

Returns: true if Terminate has been called

Implements CPN::KernelBase.

Definition at line 124 of file Kernel.cc.

References context.

                               {
         return context->IsTerminated();
     }

void CPN::Kernel::LoadNodeList ( const std::string & filename )

inline

Load a node list into the node loader.

Definition at line 258 of file Kernel.h.

258 { nodeloader.LoadNodeList(filename); }

CPN::Kernel::nodeloader

NodeLoader nodeloader

Definition: Kernel.h:353

CPN::NodeLoader::LoadNodeList

void LoadNodeList(const std::string &filename)

Definition: NodeLoader.cc:68

void CPN::Kernel::LoadSharedLib ( const std::string & libname )

inline

Attempts to load the given dynamic library and make the symbols inside available to be searched for node types. The library will be unloaded on distruction.

Parameters

libname the library name and path

Definition at line 254 of file Kernel.h.

254 { nodeloader.LoadSharedLib(libname); }

CPN::Kernel::nodeloader

NodeLoader nodeloader

Definition: Kernel.h:353

CPN::NodeLoader::LoadSharedLib

void LoadSharedLib(const std::string &libname)

Definition: NodeLoader.cc:57

void CPN::Kernel::LogState ( )

private

Definition at line 614 of file Kernel.cc.

References DONE, Logger::Error(), garbagenodes, Sync::StatusHandler< Status_t >::Get(), INITIALIZED, kernelkey, kernelname, logger, nodemap, RUNNING, server, status, TERMINATE, and useremote.

                           {
         // Note that this function does not aquire the lock...
         // this is because it is meant to be called from the debugger while
         // the application is halted and may already be in the lock or not.
         std::string statename;
         switch (status.Get()) {
         case INITIALIZED:
             statename = "initialized";
             break;
         case RUNNING:
             statename = "running";
             break;
         case TERMINATE:
             statename = "terminated";
             break;
         case DONE:
             statename = "done";
             break;
         }
         logger.Error("Kernel %s (%llu) in state %s", kernelname.c_str(), kernelkey, statename.c_str());
         logger.Error("Active nodes: %u, Garbage nodes: %u", nodemap.size(), garbagenodes.size());
         if (useremote) {
             server->LogState();
         }
         NodeMap::iterator node = nodemap.begin();
         while (node != nodemap.end()) {
             node->second->LogState();
             ++node;
         }
     }

Here is the call graph for this function:

void CPN::Kernel::NodeTerminated ( Key_t key )

Called by the node in the cleanup routine. TO BE CALLED ONLY BY THE CPN INTERNALS.

Definition at line 495 of file Kernel.cc.

References ASSERT, context, DONE, FUNCBEGIN, garbagelock, garbagenodes, Sync::StatusHandler< Status_t >::Get(), logger, nodecond, nodecond_signal, nodelock, nodemap, SendWakeup(), Sync::ReentrantCondition::Signal(), status, and Logger::Warn().

Referenced by DestroyExternalEndpoint(), and CPN::NodeBase::EntryPoint().

                                          {
         context->SignalNodeEnd(key);
         Sync::AutoReentrantLock arlock(nodelock);
         FUNCBEGIN;
         if (status.Get() == DONE) {
             logger.Warn("Nodes running after shutdown");
         } else {
             NodeMap::iterator entry = nodemap.find(key);
             ASSERT(entry != nodemap.end());
             shared_ptr<PseudoNode> node = entry->second;
             nodemap.erase(entry);
             {
                 Sync::AutoReentrantLock arlock(garbagelock);
                 garbagenodes.push_back(node);
             }
             SendWakeup();
         }
         nodecond.Signal();
         nodecond_signal = true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::Kernel::NotifyTerminate ( )

virtual

These functions are called by the context to create things remotely. Should not be called by anyone but the context!

Reimplemented from CPN::KernelBase.

Definition at line 132 of file Kernel.cc.

References Sync::StatusHandler< Status_t >::CompareAndPost(), FUNCBEGIN, RUNNING, SendWakeup(), status, and TERMINATE.

                                  {
         FUNCBEGIN;
         if (status.CompareAndPost(RUNNING, TERMINATE)) {
             SendWakeup();
         }
     }

Here is the call graph for this function:

Kernel& CPN::Kernel::operator= ( const Kernel & )

private

void CPN::Kernel::RegisterNodeFactory ( shared_ptr< NodeFactory > factory )

inline

A function that lets others register node factories.

Parameters

factory the node factory

Definition at line 281 of file Kernel.h.

281 { nodeloader.RegisterFactory(factory); }

CPN::Kernel::nodeloader

NodeLoader nodeloader

Definition: Kernel.h:353

CPN::NodeLoader::RegisterFactory

void RegisterFactory(shared_ptr< NodeFactory > factory)

Definition: NodeLoader.cc:110

void CPN::Kernel::RemoteCreateNode ( NodeAttr attr )

virtual

Reimplemented from CPN::KernelBase.

Definition at line 608 of file Kernel.cc.

References ASSERT, FUNCBEGIN, InternalCreateNode(), and useremote.

                                                {
         FUNCBEGIN;
         ASSERT(useremote);
         InternalCreateNode(attr);
     }

Here is the call graph for this function:

void CPN::Kernel::RemoteCreateQueue ( SimpleQueueAttr attr )

virtual

Reimplemented from CPN::KernelBase.

Definition at line 603 of file Kernel.cc.

References ASSERT, CreateLocalQueue(), FUNCBEGIN, and useremote.

                                                        {
         FUNCBEGIN;
         ASSERT(useremote);
         CreateLocalQueue(attr);
     }

Here is the call graph for this function:

void CPN::Kernel::RemoteCreateReader ( SimpleQueueAttr attr )

virtual

Reimplemented from CPN::KernelBase.

Definition at line 598 of file Kernel.cc.

References ASSERT, CreateReaderEndpoint(), FUNCBEGIN, and useremote.

                                                         {
         FUNCBEGIN;
         ASSERT(useremote);
         CreateReaderEndpoint(attr);
     }

Here is the call graph for this function:

void CPN::Kernel::RemoteCreateWriter ( SimpleQueueAttr attr )

virtual

Reimplemented from CPN::KernelBase.

Definition at line 593 of file Kernel.cc.

References ASSERT, CreateWriterEndpoint(), FUNCBEGIN, and useremote.

                                                         {
         FUNCBEGIN;
         ASSERT(useremote);
         CreateWriterEndpoint(attr);
     }

Here is the call graph for this function:

void CPN::Kernel::SearchDirectory ( const std::string & dirname )

inline

Add all node lists in the given directory

Definition at line 262 of file Kernel.h.

262 { nodeloader.SearchDirectory(dirname); }

CPN::Kernel::nodeloader

NodeLoader nodeloader

Definition: Kernel.h:353

CPN::NodeLoader::SearchDirectory

void SearchDirectory(const std::string &dirname)

Definition: NodeLoader.cc:78

void CPN::Kernel::SendWakeup ( )

private

Definition at line 525 of file Kernel.cc.

References nodecond, nodecond_signal, nodelock, server, Sync::ReentrantCondition::Signal(), and useremote.

Referenced by NodeTerminated(), and NotifyTerminate().

                             {
         Sync::AutoReentrantLock arlock(nodelock);
         if (useremote) {
             server->Wakeup();
         }
         nodecond.Signal();
         nodecond_signal = true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::Kernel::SwallowBrokenQueueExceptions ( )

virtual

Whether the node should by default swallow the broken queue exceptions or let them propigate as an error.

Returns: true or false

Implements CPN::KernelBase.

Definition at line 656 of file Kernel.cc.

References datalock, and swallowbrokenqueue.

Referenced by CPN::NodeBase::EntryPoint().

                                               {
         Sync::AutoReentrantLock al(datalock);
         return swallowbrokenqueue;
     }

Here is the caller graph for this function:

bool CPN::Kernel::SwallowBrokenQueueExceptions ( bool sbqe )

Definition at line 661 of file Kernel.cc.

References datalock, and swallowbrokenqueue.

                                                        {
         Sync::AutoReentrantLock al(datalock);
         return swallowbrokenqueue = sbqe;
     }

void CPN::Kernel::Terminate ( )

For the kernel to terminate. Returns immediately, use wait to wait for completion.

Definition at line 120 of file Kernel.cc.

References context.

Referenced by ~Kernel().

                            {
         context->Terminate();
     }

Here is the caller graph for this function:

bool CPN::Kernel::UseD4R ( )

virtual

Whether or not D4R should be used.

These values may be cached by queues and nodes. Setting these values after any node or queue has been created may give undeterministic behavior.

Returns: true or false (default true)

Implements CPN::KernelBase.

Definition at line 646 of file Kernel.cc.

References datalock, and useD4R.

                         {
         Sync::AutoReentrantLock al(datalock);
         return useD4R;
     }

bool CPN::Kernel::UseD4R ( bool u )

Definition at line 651 of file Kernel.cc.

References datalock, and useD4R.

                               {
         Sync::AutoReentrantLock al(datalock);
         return useD4R = u;
     }

void CPN::Kernel::Wait ( )

Waits until the main loop terminates. Will not happen until a terminate signal or Terminate is called. Use WaitForNode if you wish to wait for the nodes to be done.

Definition at line 111 of file Kernel.cc.

References Sync::StatusHandler< Status_t >::CompareAndWait(), DONE, FUNCBEGIN, FUNCEND, Sync::StatusHandler< Status_t >::Get(), and status.

Referenced by ~Kernel().

                       {
         FUNCBEGIN;
         KernelStatus_t s = status.Get();
         while (s != DONE) {
             s = status.CompareAndWait(s);
         }
         FUNCEND;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::Kernel::WaitForAllNodes ( )

Waits until there are no running nodes.

Definition at line 242 of file Kernel.cc.

References context.

                                  {
         context->WaitForAllNodeEnd();
     }

void CPN::Kernel::WaitForNode ( const std::string & nodename )

Check for the existance of the given node. Returns when it detects that the given node does not exist.

Parameters

nodename the name of the node to wait for

Exceptions

ShutdownException if the kernel has shutdown

Definition at line 237 of file Kernel.cc.

References context, and FUNCBEGIN.

                                                       {
         FUNCBEGIN;
         context->WaitForNodeEnd(nodename);
     }

void CPN::Kernel::WaitForNodeStart ( const std::string & nodename )

Wait for the given node to start.

Parameters

nodename the name of the node to wait for

Definition at line 246 of file Kernel.cc.

References context, and FUNCBEGIN.

                                                            {
         FUNCBEGIN;
         context->WaitForNodeStart(nodename);
     }

Member Data Documentation

shared_ptr<Context> CPN::Kernel::context

private

Definition at line 349 of file Kernel.h.

Referenced by CheckTerminated(), CreateExternalEndpoint(), CreateNode(), CreateQueue(), DestroyExternalEndpoint(), EntryPoint(), GetExternalIQueue(), GetExternalOQueue(), IsTerminated(), Kernel(), NodeTerminated(), Terminate(), WaitForAllNodes(), WaitForNode(), and WaitForNodeStart().

Sync::ReentrantLock CPN::Kernel::datalock

private

Definition at line 366 of file Kernel.h.

Referenced by GrowQueueMaxThreshold(), SwallowBrokenQueueExceptions(), and UseD4R().

Sync::ReentrantLock CPN::Kernel::garbagelock

private

Definition at line 363 of file Kernel.h.

Referenced by ClearGarbage(), and NodeTerminated().

NodeList CPN::Kernel::garbagenodes

private

Definition at line 364 of file Kernel.h.

Referenced by ClearGarbage(), LogState(), and NodeTerminated().

bool CPN::Kernel::growmaxthresh

private

Definition at line 369 of file Kernel.h.

Referenced by GrowQueueMaxThreshold().

Key_t CPN::Kernel::kernelkey

private

Definition at line 347 of file Kernel.h.

Referenced by CreateExternalEndpoint(), CreateNode(), CreateQueue(), EntryPoint(), Kernel(), and LogState().

const std::string CPN::Kernel::kernelname

private

Definition at line 346 of file Kernel.h.

Referenced by Kernel(), and LogState().

Logger CPN::Kernel::logger

private

Definition at line 348 of file Kernel.h.

Referenced by EntryPoint(), Kernel(), LogState(), and NodeTerminated().

Sync::ReentrantCondition CPN::Kernel::nodecond

private

Definition at line 360 of file Kernel.h.

Referenced by EntryPoint(), NodeTerminated(), and SendWakeup().

bool CPN::Kernel::nodecond_signal

private

Definition at line 361 of file Kernel.h.

Referenced by EntryPoint(), NodeTerminated(), and SendWakeup().

NodeLoader CPN::Kernel::nodeloader

private

Definition at line 353 of file Kernel.h.

Referenced by Kernel().

Sync::ReentrantLock CPN::Kernel::nodelock

private

Definition at line 359 of file Kernel.h.

Referenced by CreateExternalEndpoint(), CreateLocalQueue(), CreateReaderEndpoint(), CreateWriterEndpoint(), DestroyExternalEndpoint(), EntryPoint(), GetExternalIQueue(), GetExternalOQueue(), InternalCreateNode(), NodeTerminated(), and SendWakeup().

NodeMap CPN::Kernel::nodemap

private

Definition at line 362 of file Kernel.h.

Referenced by CreateExternalEndpoint(), CreateLocalQueue(), CreateReaderEndpoint(), CreateWriterEndpoint(), DestroyExternalEndpoint(), EntryPoint(), GetExternalIQueue(), GetExternalOQueue(), InternalCreateNode(), LogState(), and NodeTerminated().

auto_ptr<RemoteQueueHolder> CPN::Kernel::remotequeueholder

private

Definition at line 351 of file Kernel.h.

Referenced by CreateReaderEndpoint(), CreateWriterEndpoint(), EntryPoint(), and Kernel().

auto_ptr<ConnectionServer> CPN::Kernel::server

private

Definition at line 350 of file Kernel.h.

Referenced by CreateReaderEndpoint(), CreateWriterEndpoint(), EntryPoint(), Kernel(), LogState(), and SendWakeup().

Sync::StatusHandler<KernelStatus_t> CPN::Kernel::status

private

Definition at line 341 of file Kernel.h.

Referenced by EntryPoint(), InternalCreateNode(), Kernel(), LogState(), NodeTerminated(), NotifyTerminate(), and Wait().

bool CPN::Kernel::swallowbrokenqueue

private

Definition at line 368 of file Kernel.h.

Referenced by SwallowBrokenQueueExceptions().

auto_ptr<Pthread> CPN::Kernel::thread

private

Definition at line 345 of file Kernel.h.

Referenced by Kernel(), and ~Kernel().

bool CPN::Kernel::useD4R

private

Definition at line 367 of file Kernel.h.

Referenced by UseD4R().

bool CPN::Kernel::useremote

private

Definition at line 352 of file Kernel.h.

Referenced by CreateQueue(), CreateReaderEndpoint(), CreateWriterEndpoint(), EntryPoint(), Kernel(), LogState(), RemoteCreateNode(), RemoteCreateQueue(), RemoteCreateReader(), RemoteCreateWriter(), and SendWakeup().

The documentation for this class was generated from the following files:

include/cpn/Kernel.h
lib/Kernel.cc

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation