[fpc-pascal] FPC for High Performance Computing (HPC) Components with Application API

[Andrew Brunner]

I wanted to start a discussion based on current state of FPC and High
Performance Computing (HPC).

The premise of the thread is to discuss high scale threads.  Currently
FPC has matured to the point where it might be beneficial to start
targeting a particular market for users.  The first thing that comes
to mind is the university community where coding is second to theory.
Pascal offers ease of code readability and in turn brings the ability
to easily organize scientific formulas into computer code that when
arranged properly can be executed in a high scale environment,
delivering faster, near instant or instant results.

After reading a few responses in a separate discussion regarding
threading I came to realize that some work remains to FPC with regard
to High Performance Threading.  FPC is advanced in that it offers
native cross platform access to kernel threads.  FPC however, on
Linux, relies on a libc Posix Threads (pthreads) library that is a
widely adopted implement of the POSIX specification.

Microsoft has spent a lot of resources on parallel computing and it
may be beneficial for the FPC project to at least begin to explore the
possibility of FPC to be used in a professional high performance
environment.

IMO - it may be smarter to develop of a new threading paradigm.  A HPC
threading system that addresses issues with waitfor/suspend/resume and
resolve them for *nix/windows/mac but do so knowing that there are
most likely tens of thousands of threads running.

I would like to offer my commitment to this issue since FPC is ideal
for real-time computational engines.  With regard to HPC, the native
TThread object has been implemented (under *nix) with redundant
barriers in creation, suspend, and resume features.  This redundancy
makes for slow thread creation times and as such is not ideal as is.

Re-writing the current TThread implement may not prove nearly
impossible as is, because under windows Resume/Suspend Thread is
merely an API kernel call and *nix has no such API.  Even if we were
to re-write the TThreads unit to remove dependency on the pThreads
library, we would still be stuck with creating a semaphore under
linux, one per thread instance to gain Suspend/Resume functionality.

Suggested Reading:
   http://ftp.gnu.org/gnu/glibc/glibc-linuxthreads-2.3.6.tar.gz
   http://openmp.org/wp/openmp-specifications/
   http://www.gnu.org/software/libc/
   http://msdn.microsoft.com/en-us/concurrency/default.aspx

Anyone interested in consulting or helping?