Language Reference/Monitors - Revision history

Thomas Linder Puls: /* Queue */ bug missing retract

2014-04-07T08:11:41Z

Queue: bug missing retract

← Older revision		Revision as of 10:11, 7 April 2014
Line 319:		Line 319:
	dequeue guard { value_fact(_), ! }.		dequeue guard { value_fact(_), ! }.
	dequeue() = V :-		dequeue() = V :-
	value_fact(V),		retract(value_fact(V)),
	!.		!.
	dequeue() = V :-		dequeue() = V :-

Thomas Linder Puls: classInfo

2013-05-06T13:47:08Z

classInfo

← Older revision		Revision as of 15:47, 6 May 2013
Line 156:		Line 156:
	retract(element_fact(Element)),		retract(element_fact(Element)),
	!;		!;
	~~common_exception~~::raise_error(~~common_exception::classInfo, predicate_name(),~~		exception::raise_error("The guard should have ensured that the queue is not empty").
	"The guard should have ensured that the queue is not empty").

	predicates		predicates

Thomas Linder Puls: /* Guards */ example

2012-10-25T09:53:38Z

Guards: example

← Older revision		Revision as of 11:53, 25 October 2012
Line 171:		Line 171:
	}}		}}

	Guard predicates are handled in the transformation mentioned above. The queue example is effectively the same as this "monitor-free" code:		Guard predicates are handled in the transformation mentioned above.

			{{Example\|The queue example is effectively the same as this "monitor-free" code:
	<vip>class queue		<vip>class queue
	predicates		predicates
Line 221:		Line 223:
	setGuardEvents() :-		setGuardEvents() :-
	remove_guard_event:setSignaled(toBoolean(remove_guard())).		remove_guard_event:setSignaled(toBoolean(remove_guard())).
	end implement queue</vip>		end implement queue</vip>}}

	An '''event''' is created for each guard predicate; this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).		An '''event''' is created for each guard predicate; this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).

Thomas Linder Puls: Remove "preliminary documentation"

2010-05-13T19:46:32Z

Remove "preliminary documentation"

← Older revision		Revision as of 21:46, 13 May 2010
Line 1:		Line 1:
	~~{{Preliminary Documentation}}~~

	{{languageReferenceNavbar\|Monitors}}		{{languageReferenceNavbar\|Monitors}}

Thomas Linder Puls: /* Queue */ PFC link

2010-03-18T09:52:28Z

Queue: PFC link

← Older revision		Revision as of 11:52, 18 March 2010
Line 324:		Line 324:
	common_exception::raise_error(....).		common_exception::raise_error(....).
	end implement queue</vip>		end implement queue</vip>

			'''Notice''' that [[PFC]] contains a similar class <vp>monitorQueue</vp> already.

	=== References ===		=== References ===

	*[[wikipedia:Monitor (synchronization)]]		*[[wikipedia:Monitor (synchronization)]]

Thomas Linder Puls: /* Queue */ indentation

2010-03-17T18:52:01Z

Queue: indentation

← Older revision		Revision as of 20:52, 17 March 2010
Line 297:		Line 297:

	<vip>monitor interface queue{@Elem}		<vip>monitor interface queue{@Elem}
	predicates		predicates
	enqueue : (@Elem Value).		enqueue : (@Elem Value).
	predicates		predicates
	dequeue : () -> @Elem Value.		dequeue : () -> @Elem Value.
	end interface queue		end interface queue

			%-----------------------------------------
	class queue{@Elem} : queue{@Elem}		class queue{@Elem} : queue{@Elem}
	end class queue		end class queue

			%-----------------------------------------
	implement queue{@Elem}		implement queue{@Elem}
	facts		facts
	value_fact : (@Elem Value).		value_fact : (@Elem Value).

	clauses		clauses
	enqueue(V) :-		enqueue(V) :-
	assert(value_fact(V)).		assert(value_fact(V)).

	clauses		clauses
	dequeue guard { value_fact(_), ! }.		dequeue guard { value_fact(_), ! }.
	dequeue() = V :-		dequeue() = V :-
	value_fact(V),		value_fact(V),
	!.		!.
	dequeue() = V :-		dequeue() = V :-
	common_exception::raise_error(....).		common_exception::raise_error(....).
	end implement queue</vip>		end implement queue</vip>

Thomas Linder Puls: /* Shared output streams */ indentation

2010-03-17T18:50:54Z

Shared output streams: indentation

← Older revision		Revision as of 20:50, 17 March 2010
Line 265:		Line 265:
	end interface outputStream_sync		end interface outputStream_sync

			%-----------------------------------------
	class outputStream_sync : outputStream_sync		class outputStream_sync : outputStream_sync
	constructors		constructors
	new : (outputStream Stream).		new : (outputStream Stream).
	end class outputStream_sync		end class outputStream_sync

			%-----------------------------------------
	implement outputStream_sync		implement outputStream_sync
	delegate interface outputStream to stream		delegate interface outputStream to stream

	facts		facts
	stream : outputStream.		stream : outputStream.

	clauses		clauses
	new(Stream) :- stream := Stream.		new(Stream) :- stream := Stream.
	end implement outputStream_sync</vip>		end implement outputStream_sync</vip>

	You should realize however that with code like this:		You should realize however that with code like this:

	<vip> clauses		<vip>clauses
	write(...) :-		write(...) :-
	logStream:write(time::new():formatShortDate(), ": "),		logStream:write(time::new():formatShortDate(), ": "),
	logStream:write(...),		logStream:write(...),
	logStream:nl().</vip>		logStream:nl().</vip>

	consists of '''''three separate''''' operations, so it can still be the case (fx) that two threads first write the time and then one writes the "...", etc.		consists of '''''three separate''''' operations, so it can still be the case (fx) that two threads first write the time and then one writes the "...", etc.

Thomas Linder Puls: /* Writing to a log file */ indentation

2010-03-17T18:49:33Z

Writing to a log file: indentation

← Older revision		Revision as of 20:49, 17 March 2010
Line 239:		Line 239:

	<vip>monitor class log		<vip>monitor class log
	properties		properties
	logStream : outputStream.		logStream : outputStream.
	predicates		predicates
	write : (...).		write : (...).
	end class log		end class log

			%-----------------------------------------
	implement log		implement log
	class facts		class facts
	logStream : outputStream := erroneous.		logStream : outputStream := erroneous.
	clauses		clauses
	write(...) :-		write(...) :-
	logStream:write(time::new():formatShortDate(), ": "),		logStream:write(time::new():formatShortDate(), ": "),
	logStream:write(...),		logStream:write(...),
	logStream:nl().		logStream:nl().
	end implement log</vip>		end implement log</vip>

Thomas Linder Puls: /* Guards */ indentation

2010-03-17T18:48:46Z

Guards: indentation

← Older revision		Revision as of 20:48, 17 March 2010
Line 138:		Line 138:
	{{Example\| Here is a queue class that solves the pick-out problem using a guard predicate on the '''remove''' operation:		{{Example\| Here is a queue class that solves the pick-out problem using a guard predicate on the '''remove''' operation:
	<vip>monitor class queue		<vip>monitor class queue
	predicates		predicates
	insert : (integer Element).		insert : (integer Element).
	predicates		predicates
	remove : () -> integer Element.		remove : () -> integer Element.
	end class queue		end class queue

			%-----------------------------------------
	implement queue		implement queue
	class facts		class facts
	element_fact : (integer Element) nondeterm.		element_fact : (integer Element) nondeterm.

	clauses		clauses
	insert(Element) :-		insert(Element) :-
	assert(element_fact(Element)).		assert(element_fact(Element)).

	clauses		clauses
	remove guard remove_guard.		remove guard remove_guard.
	remove() = Element :-		remove() = Element :-
	retract(element_fact(Element)),		retract(element_fact(Element)),
	!;		!;
	common_exception::raise_error(common_exception::classInfo, predicate_name(),		common_exception::raise_error(common_exception::classInfo, predicate_name(),
	"The guard should have ensured that the queue is not empty").		"The guard should have ensured that the queue is not empty").

	predicates		predicates
	remove_quard : () determ.		remove_quard : () determ.
	clauses		clauses
	remove_guard() :-		remove_guard() :-
	element_fact(_),		element_fact(_),
	!.		!.
	end implement queue</vip>		end implement queue</vip>
	Notice that '''remove''' is a procedure, because threads that call remove will '''''wait''''' until there is an element for them. The guard predicate '''remove_guard''' succeeds if there is an element in the queue.		Notice that '''remove''' is a procedure, because threads that call remove will '''''wait''''' until there is an element for them. The guard predicate '''remove_guard''' succeeds if there is an element in the queue.
Line 174:		Line 175:
	Guard predicates are handled in the transformation mentioned above. The queue example is effectively the same as this "monitor-free" code:		Guard predicates are handled in the transformation mentioned above. The queue example is effectively the same as this "monitor-free" code:
	<vip>class queue		<vip>class queue
	predicates		predicates
	insert : (integer Element).		insert : (integer Element).
	predicates		predicates
	remove : () -> integer Element.		remove : () -> integer Element.
	end class queue		end class queue

			%-----------------------------------------
	implement queue		implement queue
	class facts		class facts
	monitorRegion : mutex := mutex::create(false).		monitorRegion : mutex := mutex::create(false).
	remove_guard_event : event := event::create(true, toBoolean(remove_guard())).		remove_guard_event : event := event::create(true, toBoolean(remove_guard())).
	element_fact : (integer Element) nondeterm.		element_fact : (integer Element) nondeterm.

	clauses		clauses
	insert(Element) :-		insert(Element) :-
	_W = monitorRegion:wait(),		_W = monitorRegion:wait(),
	try		try
	assert(element_fact(Element))		assert(element_fact(Element))
	finally		finally
	setGuardEvents(),		setGuardEvents(),
	monitorRegion:release()		monitorRegion:release()
	end try.		end try.

	clauses		clauses
	remove() = Element :-		remove() = Element :-
	_W = syncObject::waitAll([monitorRegion, remove_guard_event]),		_W = syncObject::waitAll([monitorRegion, remove_guard_event]),
	try		try
	retract(element_fact(Element)),		retract(element_fact(Element)),
	!;		!;
	common_exception::raise_error(common_exception::classInfo, predicate_name(),		common_exception::raise_error(common_exception::classInfo, predicate_name(),
	"The guard should have ensured that the queue is not empty")		"The guard should have ensured that the queue is not empty")
	finally		finally
	setGuardEvents(),		setGuardEvents(),
	monitorRegion:release()		monitorRegion:release()
	end try.		end try.

	class predicates		class predicates
	remove_guard : () determ.		remove_guard : () determ.
	clauses		clauses
	remove_guard() :-		remove_guard() :-
	element_fact(_),		element_fact(_),
	!.		!.

	class predicates		class predicates
	setGuardEvents : ().		setGuardEvents : ().
	clauses		clauses
	setGuardEvents() :-		setGuardEvents() :-
	remove_guard_event:setSignaled(toBoolean(remove_guard())).		remove_guard_event:setSignaled(toBoolean(remove_guard())).
	end implement queue</vip>		end implement queue</vip>
	An '''event''' is created for each guard predicate; this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).		An '''event''' is created for each guard predicate; this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).

Thomas Linder Puls: /* Semantics */ code indentation

2010-03-17T18:45:18Z

Semantics: code indentation

← Older revision		Revision as of 20:45, 17 March 2010
Line 37:		Line 37:
	The semantics is simplest to understand as a program transformation (which is how it is implemented). Consider this academic example:		The semantics is simplest to understand as a program transformation (which is how it is implemented). Consider this academic example:
	<vip>monitor class mmmm		<vip>monitor class mmmm
	predicates		predicates
	e1 : (a1 A1).		e1 : (a1 A1).
	e2 : (a2 A2).		e2 : (a2 A2).
	...		...
	en : (an An).		en : (an An).
	end class mmmm		end class mmmm

			%-----------------------------------------
	implement mmmm		implement mmmm
	clauses		clauses
	e1(A1) :- <B1>.		e1(A1) :- <B1>.

	clauses		clauses
	e2(A2) :- <B2>.		e2(A2) :- <B2>.

	...		...
	clauses		clauses
	en(An) :- <Bn>.		en(An) :- <Bn>.
	end implement mmmm</vip> Where <B1>, <B2>, ..., <Bn> are clause bodies. This code corresponds to the following "normal" code:		end implement mmmm</vip> Where <B1>, <B2>, ..., <Bn> are clause bodies. This code corresponds to the following "normal" code:
	<vip>class mmmm		<vip>class mmmm
	predicates		predicates
	e1 : (a1 A1).		e1 : (a1 A1).
	e2 : (a2 A2).		e2 : (a2 A2).
	...		...
	en : (an An).		en : (an An).
	end class mmmm		end class mmmm

			%-----------------------------------------
	implement mmmm		implement mmmm
	class facts		class facts
	monitorRegion : mutex := mutex::create(false).		monitorRegion : mutex := mutex::create(false).

	clauses		clauses
	e1(A1) :-		e1(A1) :-
	_W = monitorRegion:wait(),		_W = monitorRegion:wait(),
	try		try
	<B1>		<B1>
	finally		finally
	monitorRegion:release()		monitorRegion:release()
	end try.		end try.

	clauses		clauses
	e2(A2) :-		e2(A2) :-
	_W = monitorRegion:wait(),		_W = monitorRegion:wait(),
	try		try
	<B2>		<B2>
	finally		finally
	monitorRegion:release()		monitorRegion:release()
	end try.		end try.
	...		...
	clauses		clauses
	en(An) :-		en(An) :-
	_W = monitorRegion:wait(),		_W = monitorRegion:wait(),
	try		try
	<Bn>		<Bn>
	finally		finally
	monitorRegion:release()		monitorRegion:release()
	end try.		end try.
	end implement mmmm</vip>		end implement mmmm</vip>
	So each monitor class is extended with a mutex, which is used to create a critical region around each entry body.		So each monitor class is extended with a mutex, which is used to create a critical region around each entry body.