#include <ActivityManager.hpp>

Static Public Member Functions
static void	live (size_t)

static void	liveGeneral (int reason)

static void	addWaitingActivity (RexxActivity *a, bool release)

static wholenumber_t	addWaitingActivityCounter ()

static bool	hasWaiters ()

static RexxActivity *	findActivity ()

static RexxActivity *	findActivity (thread_id_t)

static RexxActivity *	getActivity ()

static void	returnActivity (RexxActivity *)

static void	activityEnded (RexxActivity *)

static void	shutdown ()

static void	checkShutdown ()

static void	createInterpreter ()

static void	terminateInterpreter ()

static void	lockKernel ()

static void	unlockKernel ()

static bool	lockKernelImmediate ()

static void	createLocks ()

static void	closeLocks ()

static void	init ()

static RexxActivation *	newActivation (RexxActivity activity, RexxActivation parent, RoutineClass routine, RexxCode code, RexxString calltype, RexxString environment, int context)

static RexxActivation *	newActivation (RexxActivity activity, RexxActivation parent, RexxCode *code, int context)

static RexxActivation *	newActivation (RexxActivity activity, RexxActivation parent, RexxMethod method, RexxCode code)

static RexxNativeActivation *	newNativeActivation (RexxActivity activity, RexxActivation parent)

static RexxNativeActivation *	newNativeActivation (RexxActivity *activity)

static RexxActivity *	createNewActivity ()

static RexxActivity *	createCurrentActivity ()

static RexxActivity *	createNewActivity (RexxActivity *)

static void	haltAllActivities (RexxString *)

static void	traceAllActivities (bool on)

static bool	setActivityTrace (thread_id_t thread_id, bool on_or_off)

static void	clearActivityPool ()

static bool	poolActivity (RexxActivity *activity)

static bool	haltActivity (thread_id_t thread_id, RexxString *description)

static void	yieldCurrentActivity ()

static wholenumber_t	yieldCounter ()

static void	exit (int retcode)

static void	relinquish (RexxActivity *activity)

static wholenumber_t	relinquishCounter ()

static RexxActivity *	getRootActivity ()

static void	returnRootActivity (RexxActivity *activity)

static RexxActivity *	attachThread ()

static RexxObject *	getLocalEnvironment (RexxString *name)

static RexxDirectory *	getLocal ()

static void	postTermination ()

static void	waitForTermination (const char *ds, int di)

Static Public Attributes
static RexxActivity *volatile	currentActivity = OREF_NULL

Protected Types
enum	{ MAX_THREAD_POOL_SIZE = 5 }

Static Protected Attributes
static RexxList *	activeActivities

static RexxList *	availableActivities = OREF_NULL

static RexxList *	allActivities = OREF_NULL

static RexxIdentityTable *	subClasses

static bool	processTerminating = false

static size_t	interpreterInstances = 0

static SysMutex	kernelSemaphore

static SysSemaphore	terminationSem

static volatile bool	sentinel = false

static std::deque< RexxActivity * >	waitingActivities

Detailed Description

Definition at line 49 of file ActivityManager.hpp.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

protected

Enumerator
MAX_THREAD_POOL_SIZE

Definition at line 111 of file ActivityManager.hpp.

Member Function Documentation

◆ activityEnded()

void ActivityManager::activityEnded ( RexxActivity * activityObject )

static

Return an activity to the activity pool.

Parameters

activityObject The released activity.

Definition at line 656 of file ActivityManager.cpp.

References allActivities, RexxList::items(), postTermination(), processTerminating, and RexxList::removeItem().

Referenced by RexxActivity::runThread().

◆ addWaitingActivity()

void ActivityManager::addWaitingActivity	(	RexxActivity *	waitingAct,
		bool	release
	)

static

Add a waiting activity to the waiting queue.

Parameters

waitingAct	The activity to queue up.
release	If true, the kernel lock should be released on completion.

Definition at line 132 of file ActivityManager.cpp.

References addWaitingActivityCount, RexxActivity::clearWait(), currentActivity, RexxActivity::getNumericSettings(), hasWaiters(), lockKernel(), ResourceSection::reacquire(), ResourceSection::release(), sentinel, Numerics::setCurrentSettings(), unlockKernel(), RexxActivity::waitForDispatch(), waitingActivities, and SysActivity::yield().

Referenced by relinquish(), and RexxActivity::requestAccess().

◆ addWaitingActivityCounter()

wholenumber_t ActivityManager::addWaitingActivityCounter ( )

static

Definition at line 121 of file ActivityManager.cpp.

References addWaitingActivityCount.

Referenced by RexxActivation::rexxVariable().

◆ attachThread()

RexxActivity * ActivityManager::attachThread ( )

static

Attach an activity to an interpreter instance

Parameters

instance The interpreter instance involved.

Returns: Either an existing activity, or a new activity created for this thread.

Definition at line 747 of file ActivityManager.cpp.

References createCurrentActivity(), currentActivity, findActivity(), lockKernel(), OREF_NULL, RexxActivity::requestAccess(), sentinel, RexxActivity::setNestedActivity(), RexxActivity::setSuspended(), and unlockKernel().

Referenced by InterpreterInstance::attachThread().

◆ checkShutdown()

static void ActivityManager::checkShutdown ( )

static

◆ clearActivityPool()

void ActivityManager::clearActivityPool ( )

static

Definition at line 407 of file ActivityManager.cpp.

References availableActivities, OREF_NULL, RexxList::removeFirstItem(), and RexxActivity::terminatePoolActivity().

Referenced by shutdown().

◆ closeLocks()

void ActivityManager::closeLocks ( )

static

Create the global kernel lock for the ActivityManager.

Definition at line 592 of file ActivityManager.cpp.

References SysSemaphore::close(), SysMutex::close(), kernelSemaphore, and terminationSem.

Referenced by Interpreter::processShutdown().

◆ createCurrentActivity()

RexxActivity * ActivityManager::createCurrentActivity ( )

static

Create an activity object for the current thread.

Returns

Definition at line 375 of file ActivityManager.cpp.

References allActivities, and RexxList::append().

Referenced by attachThread(), and getRootActivity().

◆ createInterpreter()

void ActivityManager::createInterpreter ( )

static

Terminate an interpreter instance. This starts process shutdown if the last instance goes away.

Definition at line 211 of file ActivityManager.cpp.

References interpreterInstances.

◆ createLocks()

void ActivityManager::createLocks ( )

static

Create the global kernel lock for the ActivityManager.

Definition at line 581 of file ActivityManager.cpp.

References SysSemaphore::create(), SysMutex::create(), kernelSemaphore, SysSemaphore::reset(), and terminationSem.

Referenced by Interpreter::processStartup().

◆ createNewActivity() [1/2]

RexxActivity * ActivityManager::createNewActivity ( )

static

Obtain a new activity for running on a separate thread.

Returns: The created (or pooled) activity object.

Definition at line 344 of file ActivityManager.cpp.

References allActivities, RexxList::append(), availableActivities, OREF_NULL, ResourceSection::reacquire(), ResourceSection::release(), RexxList::removeFirstItem(), and RexxActivity::reset().

Referenced by createNewActivity(), new_activity(), and InterpreterInstance::spawnActivity().

◆ createNewActivity() [2/2]

RexxActivity * ActivityManager::createNewActivity ( RexxActivity * parent )

static

Clone off an activity from an existing activity. Used for message start() are early reply operations.

Parameters

parent The currently running activity. The activity-specific settings are inherited from the parent.

Returns: A new activity.

Definition at line 397 of file ActivityManager.cpp.

References createNewActivity(), and RexxActivity::inheritSettings().

◆ exit()

void ActivityManager::exit ( int retcode )

static

Definition at line 549 of file ActivityManager.cpp.

◆ findActivity() [1/2]

RexxActivity * ActivityManager::findActivity ( )

static

Definition at line 540 of file ActivityManager.cpp.

References SysActivity::queryThreadID().

Referenced by attachThread(), getActivity(), getRootActivity(), haltActivity(), and setActivityTrace().

◆ findActivity() [2/2]

RexxActivity * ActivityManager::findActivity ( thread_id_t threadId )

static

Definition at line 514 of file ActivityManager.cpp.

References allActivities, RexxList::getValue(), RexxActivity::isSuspended(), RexxActivity::isThread(), RexxList::lastIndex(), LIST_END, OREF_NULL, and RexxList::previousIndex().

◆ getActivity()

RexxActivity * ActivityManager::getActivity ( )

static

Get an already existing activity for the current thread and give it kernel access before returning. This will fail if the thread has not been properly attached.

Returns: The activity for this thread.

Definition at line 790 of file ActivityManager.cpp.

References RexxActivity::enterCurrentThread(), findActivity(), and OREF_NULL.

Referenced by NativeContextBlock::NativeContextBlock().

◆ getLocal()

RexxDirectory * ActivityManager::getLocal ( )

static

Retrieve the current .local directory instance.

Returns: The .local directory for the current activity.

Definition at line 854 of file ActivityManager.cpp.

References currentActivity, RexxActivity::getLocal(), and OREF_NULL.

Referenced by RexxDirectory::atRexx(), and RexxLocal::local().

◆ getLocalEnvironment()

RexxObject * ActivityManager::getLocalEnvironment ( RexxString * name )

static

Retrieve a variable from the current local environment object.

Parameters

name	The name of the environment variable.

Returns: The object stored in .local at the requested name.

Definition at line 839 of file ActivityManager.cpp.

References currentActivity, RexxActivity::getLocalEnvironment(), OREF_NULL, and TheNilObject.

Referenced by RexxSource::findClass(), Interpreter::findClass(), and Interpreter::getCurrentQueue().

◆ getRootActivity()

RexxActivity * ActivityManager::getRootActivity ( )

static

Get a root activity for a new interpreter instance.

Returns: The newly created activity.

Definition at line 680 of file ActivityManager.cpp.

References RexxActivity::activate(), createCurrentActivity(), currentActivity, findActivity(), lockKernel(), OREF_NULL, RexxActivity::requestAccess(), sentinel, RexxActivity::setInterpreterRoot(), RexxActivity::setNestedActivity(), RexxActivity::setSuspended(), and unlockKernel().

Referenced by Interpreter::createInterpreterInstance().

◆ haltActivity()

bool ActivityManager::haltActivity	(	thread_id_t	thread_id,
		RexxString *	description
	)

static

Definition at line 455 of file ActivityManager.cpp.

References findActivity(), RexxActivity::halt(), and OREF_NULL.

Referenced by RexxHaltThread().

◆ haltAllActivities()

static void ActivityManager::haltAllActivities ( RexxString * )

static

◆ hasWaiters()

static bool ActivityManager::hasWaiters ( )

inlinestatic

Definition at line 57 of file ActivityManager.hpp.

References waitingActivities.

Referenced by addWaitingActivity(), and relinquish().

◆ init()

void ActivityManager::init ( void )

static

Initialize the activity manager when the interpreter starts up.

Definition at line 79 of file ActivityManager.cpp.

References allActivities, availableActivities, currentActivity, new_list(), and OREF_NULL.

Referenced by RexxMemory::createImage(), and RexxMemory::restore().

◆ live()

void ActivityManager::live ( size_t liveMark )

static

Definition at line 86 of file ActivityManager.cpp.

References allActivities, availableActivities, and memory_mark.

Referenced by RexxMemory::live().

◆ liveGeneral()

void ActivityManager::liveGeneral ( int reason )

static

Definition at line 101 of file ActivityManager.cpp.

References allActivities, availableActivities, memory_mark_general, memoryObject, and RexxMemory::savingImage().

Referenced by RexxMemory::liveGeneral().

◆ lockKernel()

void ActivityManager::lockKernel ( )

static

Definition at line 557 of file ActivityManager.cpp.

References kernelSemaphore, and SysMutex::request().

Referenced by addWaitingActivity(), attachThread(), and getRootActivity().

◆ lockKernelImmediate()

bool ActivityManager::lockKernelImmediate ( )

static

Try a fast request for the kernel. This requires A) there be no waiting activities and B) that it be possible to request the semaphore without waiting.

Returns: true if the semaphore was obtained, false if the kernel is not locked by this activity.

Definition at line 607 of file ActivityManager.cpp.

References kernelSemaphore, SysMutex::requestImmediate(), and waitingActivities.

Referenced by RexxActivity::requestAccess().

◆ newActivation() [1/3]

RexxActivation * ActivityManager::newActivation	(	RexxActivity *	activity,
		RexxActivation *	parent,
		RexxCode *	code,
		int	context
	)

static

Create a new activation for an internal level call (internal call or interpreted execution).

Parameters

activity	The activity we're running on.
parent	The parent activation. OREF_NULL is used if this is a top-level call.
code	The code object associated with the method.
context	The context of the invocation.

Returns: The newly created activation.

Definition at line 282 of file ActivityManager.cpp.

◆ newActivation() [2/3]

RexxActivation * ActivityManager::newActivation	(	RexxActivity *	activity,
		RexxActivation *	parent,
		RexxMethod *	method,
		RexxCode *	code
	)

static

Create a new activation for a method invocation (vs. a program or routine call)

Parameters

activity	The activity we're running on.
method	The method object being invoked.
code	The code object associated with the method.

Returns: The newly created activation.

Definition at line 300 of file ActivityManager.cpp.

◆ newActivation() [3/3]

RexxActivation * ActivityManager::newActivation	(	RexxActivity *	activity,
		RexxActivation *	parent,
		RoutineClass *	routine,
		RexxCode *	code,
		RexxString *	calltype,
		RexxString *	environment,
		int	context
	)

static

Create a new activation for a toplevel activation using a routine (vs. a method invocation).

Parameters

activity	The activity we're running on.
routine	The routine object we're calling.
code	The code object associated with the method.
calltype	The type of call being made.
environment	The initial address environment.
context	The context of the invocation.

Returns: The newly created activation.

Definition at line 262 of file ActivityManager.cpp.

Referenced by RexxCode::call(), RexxActivation::debugInterpret(), RexxActivation::internalCall(), RexxActivation::internalCallTrap(), RexxActivation::interpret(), and RexxCode::run().

◆ newNativeActivation() [1/2]

RexxNativeActivation * ActivityManager::newNativeActivation ( RexxActivity * activity )

static

Create a new activation for a a native external call stack

Parameters

activity The activity we're running on.

Returns: The newly created activation.

Definition at line 331 of file ActivityManager.cpp.

◆ newNativeActivation() [2/2]

RexxNativeActivation * ActivityManager::newNativeActivation	(	RexxActivity *	activity,
		RexxActivation *	parent
	)

static

Create a new activation for a a native external call stack

Parameters

activity	The activity we're running on.
parent	The parent activation.

Returns: The newly created activation.

Definition at line 316 of file ActivityManager.cpp.

Referenced by RexxNativeRoutine::call(), RegisteredRoutine::call(), RexxActivity::createNewActivationStack(), RexxActivity::exitKernel(), RexxActivity::run(), and RexxNativeMethod::run().

◆ poolActivity()

bool ActivityManager::poolActivity ( RexxActivity * activity )

static

Return an activity to the available pool. If we're in the process of shutting down, or have too many pool activities, we'll return false to tell the activity to completely shut things down.

Parameters

activity The activity we're adding back to the available pool.