Thread.library - Revision history

Molly: /* unit documentation */ Added thread library documentation.

2013-11-30T15:58:15Z

unit documentation: Added thread library documentation.

Show changes

Molly: Added initial paragraph unit documentation

2013-11-30T15:53:23Z

Added initial paragraph unit documentation

Molly: /* the unit */ Fixed case in library diskname (AOS is sensitive in this matter)

2013-11-25T23:34:37Z

the unit: Fixed case in library diskname (AOS is sensitive in this matter)

Molly: /* Example: Two threads */ Corrected link to original c-source

2013-10-18T05:15:55Z

Example: Two threads: Corrected link to original c-source

Molly: /* Example: Single thread */ corrected link to original c-source

2013-10-18T05:15:01Z

Example: Single thread: corrected link to original c-source

Molly: /* Example: Broadcasting a condition */ Added pascal-source

2013-09-20T17:09:19Z

Example: Broadcasting a condition: Added pascal-source

Molly: /* Example: Signalling a condition */ Added pascal-source

2013-09-20T17:08:15Z

Example: Signalling a condition: Added pascal-source

Molly: /* Example: Using a mutex amongst threads */ Added pascal-source

2013-09-20T17:07:10Z

Example: Using a mutex amongst threads: Added pascal-source

Molly: /* Example: Subthreads (and lot's of them) */ Added pascal-source

2013-09-20T17:05:35Z

Example: Subthreads (and lot's of them): Added pascal-source

Molly: /* Example: Multiple threads */ Added pascal-source

2013-09-20T17:02:41Z

Example: Multiple threads: Added pascal-source

← Older revision		Revision as of 15:53, 30 November 2013
Line 857:		Line 857:

	end.		end.
		+	</source>
		+
		+	=== unit documentation ===
		+	A bit rough around the edges. No var /var was done, and only some basic links to other units (types etc.).
		+	<source lang="xml">
	</source>		</source>

@@ Line 851: / Line 851: @@
 Initialization
-   ThreadBase := OpenLibrary('Thread.library',0);
+   ThreadBase := OpenLibrary('thread.library',0);
 Finalization

@@ Line 54: / Line 54: @@
 === Example: Two threads ===
-Original c-source [http://repo.or.cz/w/AROS-Contrib.git/blob/HEAD:/libs/thread/test/cleanupatexit.c]
+Original c-source [http://repo.or.cz/w/AROS-Contrib.git/blob/HEAD:/libs/thread/test/twothreads.c]
 <source lang="pascal">

@@ Line 5: / Line 5: @@
 === Example: Single thread ===
-Original c-source [http://aros.sourceforge.net/documentation/developers/samplecode/helloworld.c]
+Original c-source [http://repo.or.cz/w/AROS-Contrib.git/blob/HEAD:/libs/thread/test/cleanupatexit.c]
 <source lang="pascal">

← Older revision		Revision as of 17:09, 20 September 2013
Line 511:		Line 511:

	<source lang="pascal">		<source lang="pascal">
		+	Program BroadcastCond;

		+	{$MODE OBJFPC} {$H+}
		+
		+	uses
		+	exec, amigados, contrib_thread;
		+
		+
		+	Type
		+	pthread_data = ^tthread_data;
		+	TThread_Data = record
		+	mutex : pvoid;
		+	cond : pvoid;
		+	end;
		+
		+
		+
		+	Function waiter_thread(data: pvoid): pvoid; cdecl;
		+	var
		+	td : pthread_data;
		+	id : uint32_t;
		+	ThisOutput : Text;
		+	begin
		+	{$WARNING "Grabbing Output from main thread in this manner is not thread-safe"}
		+	ThisOutput := System.Output;
		+
		+	td := data;
		+	id := CurrentThread();
		+
		+	writeln(ThisOutput, '[',id,'] starting, locking the mutex');
		+	LockMutex(td^.mutex);
		+
		+	writeln(ThisOutput, '[',id,'] waiting on the condition');
		+	WaitCondition(td^.cond, td^.mutex);
		+
		+	writeln(ThisOutput, '[',id,'] condition signalled, unlocking the mutex');
		+	UnlockMutex(td^.mutex);
		+
		+	writeln(ThisOutput, '[',id,'] all done, exiting');
		+
		+	result := nil;
		+	end;
		+
		+
		+
		+	var
		+	td : pthread_data;
		+	i : integer;
		+
		+
		+	Begin
		+	writeln('enter');
		+
		+	td := Exec.AllocMem(sizeof(tthread_data), MEMF_PUBLIC or MEMF_CLEAR);
		+
		+	writeln('creating mutex');
		+	td^.mutex := CreateMutex();
		+
		+	writeln('creating condition');
		+	td^.cond := CreateCondition();
		+
		+	writeln('starting waiter threads');
		+	for i := 0 to 5-1
		+	do CreateThread(@waiter_thread, td);
		+
		+	writeln('sleeping for 2s');
		+	DOSDelay(100);
		+
		+	writeln('signalling condition');
		+	SignalCondition(td^.cond);
		+
		+	writeln('sleeping for 2s');
		+	DOSDelay(100);
		+
		+
		+	writeln('broadcasting condition');
		+	BroadcastCondition(td^.cond);
		+
		+	writeln('waiting for threads to exit');
		+	WaitAllThreads();
		+
		+	writeln('destroying the condition');
		+	DestroyCondition(td^.cond);
		+
		+	writeln('destroying the mutex');
		+	DestroyMutex(td^.mutex);
		+
		+
		+	ExecFreeMem(td, sizeof(tthread_data));
		+	writeln('all done');
		+
		+	ExitCode := 0;
		+
		+	writeln('leave');
		+	End.
	</source>		</source>

← Older revision		Revision as of 17:08, 20 September 2013
Line 417:		Line 417:

	<source lang="pascal">		<source lang="pascal">
		+	program signalcond;

		+
		+	{$MODE OBJFPC} {$H+}
		+
		+
		+	uses
		+	exec, amigados, contrib_thread;
		+
		+
		+	Type
		+	PThread_Data = ^TThread_Data;
		+	TThread_Data = record
		+	mutex: pvoid;
		+	cond : pvoid;
		+	end;
		+
		+
		+
		+	function waiter_thread(data: pvoid): pvoid; cdecl;
		+	var
		+	td : pThread_Data;
		+	id : uint32_t;
		+	ThisOutput : Text;
		+	Begin
		+	{$WARNING "Grabbing Output from main thread in this manner is not thread-safe"}
		+	ThisOutput := System.Output;
		+
		+	td := data;
		+	id := CurrentThread();
		+
		+	writeln(ThisOutput, '[',id,'] starting, locking the mutex');
		+	LockMutex(td^.mutex);
		+
		+	writeln(ThisOutput,'[',id,'] waiting on the condition');
		+	WaitCondition(td^.cond, td^.mutex);
		+
		+	writeln(ThisOutput,'[',id,'] condition signalled, unlocking the mutex');
		+	UnlockMutex(td^.mutex);
		+
		+	writeln(ThisOutput,'[',id,'] all done, exiting');
		+
		+	result := nil;
		+	end;
		+
		+
		+
		+	var
		+	td : pthread_data;
		+	tw : uint32_t;
		+	begin
		+	writeln('enter');
		+
		+	td := AllocMem(sizeOf(TThread_data), MEMF_PUBLIC or MEMF_CLEAR);
		+
		+	writeln('creating mutex');
		+	td^.mutex := CreateMutex();
		+
		+	writeln('creating condition');
		+	td^.cond := CreateCondition();
		+
		+	writeln('starting waiter thread');
		+	tw := CreateThread(@waiter_thread, td);
		+
		+	writeln('sleeping for 2s');
		+	DosDelay(100);
		+
		+	writeln('signalling condition');
		+	SignalCondition(td^.cond);
		+
		+	writeln('waiting for waiter thread');
		+	WaitThread(tw, nil);
		+
		+	writeln('destroying the condition');
		+	DestroyCondition(td^.cond);
		+
		+	writeln('destroying the mutex');
		+	DestroyMutex(td^.mutex);
		+
		+	FreeMem(td, sizeof(TThread_Data));
		+
		+	writeln('all done');
		+
		+	ExitCode := 0;
		+
		+	writeln('leave');
		+	end.
	</source>		</source>

← Older revision		Revision as of 17:07, 20 September 2013
Line 315:		Line 315:

	<source lang="pascal">		<source lang="pascal">
		+	program mutex;
		+
		+
		+	{$MODE OBJFPC} {$H+}
		+
		+
		+	uses
		+	exec, amigados, contrib_thread;
		+
		+
		+	function locker_thread(data: pvoid): pvoid; cdecl;
		+	var
		+	mutex : pvoid;
		+	id : uint32_t;
		+	ThisOutput : Text;
		+	begin
		+	{$WARNING "Grabbing Output from main thread in this manner is not thread-safe"}
		+	ThisOutput := System.Output;
		+
		+	mutex := data;
		+	id := CurrentThread();
		+
		+	writeln(ThisOutput, '[',id,'] starting, locking the mutex');
		+	LockMutex(mutex);
		+
		+	writeln(ThisOutput, '[',id,'] got it, pausing for 5s');
		+	DosDelay(250);
		+
		+	writeln(ThisOutput, '[',id,'] unlocking the mutex');
		+	UnlockMutex(mutex);
		+
		+	writeln(ThisOutput, '[',id,'] all done, exiting');
		+
		+	result := nil;
		+	end;
		+
		+
		+	function waiter_thread(data: pvoid): pvoid; cdecl;
		+	var
		+	mutex : pvoid;
		+	id : uint32_t;
		+	ThisOutput : Text;
		+	begin
		+	{$WARNING "Grabbing Output from main thread in this manner is not thread-safe"}
		+	ThisOutput := System.Output;
		+
		+	mutex := data;
		+	id := CurrentThread();
		+
		+	writeln(ThisOutput, '[',id,'] starting, locking the mutex');
		+	LockMutex(mutex);
		+
		+	writeln(ThisOutput, '[',id,'] got it, unlocking');
		+	UnlockMutex(mutex);
		+
		+	writeln(ThisOutput, '[',id,'] all done, exiting');
		+
		+	result := nil;
		+	end;
		+
		+
		+
		+	var
		+	thismutex : pvoid;
		+	tw, tl : uint32_t;
		+
		+	begin
		+	writeln('enter');
		+
		+	writeln('creating mutex');
		+	thismutex := CreateMutex();
		+
		+	writeln('starting locker thread');
		+	tl := CreateThread(@locker_thread, thismutex);
		+
		+	writeln('sleeping for 2s');
		+	DosDelay(100);
		+
		+	writeln('starting waiter thread');
		+	tw := CreateThread(@waiter_thread, thismutex);
		+
		+	writeln('waiting for locker thread to exit');
		+	WaitThread(tl, nil);
		+
		+	writeln('waiting for waiter thread to exit');
		+	WaitThread(tw, nil);
		+
		+	writeln('destroying the mutex');
		+	DestroyMutex(thismutex);
		+
		+	writeln('all done');
		+
		+	writeln('leave');
		+	end.

	</source>		</source>

← Older revision		Revision as of 17:05, 20 September 2013
Line 201:		Line 201:

	<source lang="pascal">		<source lang="pascal">
		+	Program ExitThread;
		+
		+
		+	{$MODE OBJFPC} {$H+}
		+
		+	{
		+	Because this example creates _a lot_ of subthreads
		+	we run out of stack. So we compensate otherwise we
		+	would recieve a RUNTIME ERROR 202 (Stack overflow
		+	error).
		+	}
		+
		+	{$M 2000000, 2000000}
		+
		+	uses
		+	amigados, contrib_thread;
		+
		+
		+
		+	Function thread_sub(data: pvoid): pvoid; cdecl;
		+	var
		+	id: uint32_t;
		+	ThisOutput : Text;
		+	begin
		+	{$WARNING "Grabbing Output from main thread in this manner is not thread-safe"}
		+	ThisOutput := System.Output;
		+
		+	id := CurrentThread();
		+
		+	writeln(ThisOutput, '[', id, '] starting sub');
		+
		+	DosDelay(50);
		+
		+	writeln(ThisOutput, '[', id, '] exiting sub');
		+
		+	contrib_thread.ExitThread(pvoid(id));
		+
		+	result := nil;
		+	end;
		+
		+
		+
		+	Function thread_main(data: pvoid): pvoid; cdecl;
		+	var
		+	i : integer;
		+	id_sub : Array[0..10-1] of uint32_t;
		+	ret : uint32_t;
		+	id : uint32_t;
		+	ThisOutput : Text;
		+	begin
		+	{$WARNING "Grabbing Output from main thread in this manner is not thread-safe"}
		+	ThisOutput := System.Output;
		+
		+	id := CurrentThread();
		+
		+	writeln(ThisOutput, '[', id, '] starting');
		+
		+	DosDelay(50);
		+
		+	for i := 0 to 10-1 do
		+	begin
		+	id_sub[i] := CreateThread(@thread_sub, nil);
		+	writeln(ThisOutput, 'created sub thread ', id_sub[i]);
		+	end;
		+
		+	writeln(ThisOutput, '[', id, '] exiting');
		+
		+	for i := 0 to 10-1 do
		+	begin
		+	writeln(ThisOutput, 'waiting for sub thread ', id_sub[i]);
		+	WaitThread(id_sub[i], @ret);
		+	writeln(ThisOutput, 'sub thread ', id_sub[i], ' return ', ret);
		+	end;
		+
		+	contrib_Thread.ExitThread(pvoid(id));
		+
		+	result := nil;
		+	end;
		+
		+
		+
		+	Var
		+	i : Integer;
		+	id : Array[0..10-1] of uint32_t;
		+	ret : uint32_t;
		+
		+	Begin
		+	writeln('enter');
		+
		+	for i := 0 to 10-1 do
		+	begin
		+	id[i] := CreateThread(@thread_main, nil);
		+	writeln('created thread ', id[i]);
		+	end;
		+
		+	for i := 0 to 10-1 do
		+	begin
		+	writeln('waiting for thread ', id[i]);
		+	WaitThread(id[i], @ret);
		+	writeln('thread ', id[i], ' return ', ret);
		+	end;
		+
		+	ExitCode := 0;
		+
		+	writeln('leave');
		+	End.

	</source>		</source>

← Older revision		Revision as of 17:02, 20 September 2013
Line 141:		Line 141:

	<source lang="pascal">		<source lang="pascal">
		+	Program ThreadExit;

		+	{$MODE OBJFPC} {$H+}
		+
		+	uses
		+	amigados, contrib_thread;
		+
		+
		+	Function thread_main(data: pvoid): pvoid; cdecl;
		+	var
		+	id: uint32_t;
		+	ThisOutput : Text;
		+	begin
		+	{$WARNING "Grabbing Output from main thread in this manner is not thread-safe"}
		+	ThisOutput := System.Output;
		+
		+	id := CurrentThread();
		+
		+	writeln(ThisOutput, '[', id, '] starting');
		+
		+	DosDelay(50);
		+
		+	writeln(ThisOutput, '[', id, '] exiting');
		+
		+	result := pvoid(id);
		+	end;
		+
		+
		+
		+	Var
		+	i : Integer;
		+	id : Array[0..10-1] of uint32_t;
		+	ret : uint32_t;
		+	Begin
		+	writeln('enter');
		+
		+	for i := 0 to 10-1 do
		+	begin
		+	id[i] := CreateThread(@thread_main, nil);
		+	writeln('created thread ', id[i]);
		+	DosDelay(25);
		+	end;
		+
		+	for i := 0 to 10-1 do
		+	begin
		+	writeln('waiting for thread ', id[i]);
		+	WaitThread(id[i], @ret);
		+	writeln('thread ', id[i], 'return ', ret);
		+	end;
		+
		+	ExitCode := 0;
		+	writeln('leave');
		+	End.
	</source>		</source>