Hello Free Pascal community!
I'm pleased to announce the extension of TThread's interface to bring it
more on par with current Delphi versions.
Extensions:
Note: in the following list "class" means that the property or method is
a class property or method and thus can be called without a specific
TThread instance.
New properties:
- Finished:
Returns whether the thread has finished it's execution whereas it
does not depend on whether the thread finished itself or an exception
happened.
- CurrentThread (class):
Returns a TThread instance of the current thread even if the thread
wasn't originally started through a TThread instance. This is useful if
you have some thread aware procedure and function which then needs
access to the TThread instance to do a Synchronize or Queue call. For
external threads a TThread instance is created on the fly and freed at
the end of the application (see also Future Developments).
- ExternalThread:
Returns whether the thread was not started through a TThread
instance (or one of its descendants), but was started from an external
source. Examples when this is true is for threads created by
BeginThread, for the main thread and threads created by libraries. See
also CurrentThread.
- ProcessorCount (class):
Returns the count of CPU cores detected by the RTL. This is based
on the new global property System.GetCPUCount which needs to be
implemented per target. Currently only a default implementation exists
which returns "1".
- IsSingleProcessor (class):
Returns whether the application is running on a single processor system.
New methods:
- GetTickCount (class, deprecated):
Returns the value of SysUtils.GetTickCount.
- GetTickCount64 (class):
Returns the value of SysUtils.GetTickCount64.
- Yield (class):
Calls System.ThreadSwitch to give another thread (maybe even from
another process) the change to do its work.
- CheckTerminated (class):
Returns the value of TThread.Terminated of the current thread if
the thread was created using TThread or raises an
EThreadExternalException otherwise.
- SetReturnValue (class):
Allows to set the value returned by TThread.WaitFor for the current
thread if the thread was created using TThread or raises an
EThreadExternalException otherwise.
- SpinWait (class):
Does a busy wait for the given amount of iterations (useful to burn
just a few CPU cycles).
- CreateAnonymousThread (class):
Creates a new TThread instance based on a global procedure. The
thread is started suspended and with FreeOnTerminate set. Use Start on
the returned TThread instance to start the thread's execution.
- GetSystemTimes (class):
This fills a TThread.TSystemTimes record with the time the process
has spend in different states. This method is platform specific and by
default just zeros the record.
- NameThreadForDebugging (class):
This gives the thread with the given thread ID (or the current
thread if the ID is -1) the given name. This way the thread can be
easily identified when debugging. This method is platform specific and
by default it does nothing.
- Queue (class):
The given method pointer is added to a queue that is processed by
CheckSynchronize and therefore executed inside the main thread. Unlike
Synchronize this is not a blocking call. If the thread instance is Nil
the thread is determined using TThread.CurrentThread. See also
CheckSynchronize.
- Queue (protected):
The same as the class method Queue, but with the difference that
always the current TThread instance (Self) is used.
- RemoveQueuedEvents (class):
If a TThread instance is given all queued methods (excluding
Synchronize ones) of that thread are removed from the queue processed by
CheckSynchronize. If no thread is given, but a method pointer all queued
entries (excluding Synchronize ones) with that method are removed no
matter which thread added them. If both the thread and the method is
given the thread takes precedence.
CheckSynchronize:
This function now processes a complete queue of thread events (queued by
either TThread.Synchronize or TThread.Queue) unlike before where only a
single event was handled. Like before if an Exception happens inside a
method added by Synchronize the exception is passed back to the calling
method. For methods added by Queue the exception is raised (after the
queued entry was removed from the queue).
For platform developers:
Unlike implementing directly TThread's constructor and destructor new
methods SysCreate and SysDestroy were added which must be implemented
for platform specific initialization/finialization of a thread.
All platform maintainers should check whether their platforms still
compile and - if it supports multi threading - still runs correctly. At
least Unix and Windows platforms do compile and Unix platforms do run.
Future developments:
Currently a usage of TThread.CurrentThread inside an external thread
will create a TThread instance that exists till the end of the program.
Using notification mechanism provided by the threading implementation
(TLS entry on Windows and thread destroy callbacks for pthreads) one can
make the extension that such instances are freed once the corresponding
external thread terminates. For other platforms the collector provided
in the following bug report could be used:
http://bugs.freepascal.org/view.php?id=17300 (comment 47406)
The methods NameThreadForDebugging and GetSystemTimes need to be
implemented for those platforms that support it.
Once anonymous procedures are supported the argument for
CreateAnonymousThread will be adjusted and corresponding overloads for
Synchronize and Queue will be added.
Maybe in the future a look at extending the language with keywords that
were introduced for Oxygene can be done (see
http://wiki.freepascal.org/OpenMP_support#Proposal_3 )
Regards,
Sven
_______________________________________________
fpc-pascal maillist - fpc-pascal@lists.freepascal.org
http://lists.freepascal.org/mailman/listinfo/fpc-pascal
