dkFlyer - libdkhpc

Cross-Platform, Portable HPC Framework Library

• View Tests.
• The HPC Framework is a Multi-Million Dollar, intensely tested development to:
• provide high speed, extremely simple to use and multiple functionality
  for High Performance Computing and Clustering.
• As it automatically performs over 90% of the 'tough code' required to creating an application,
  this library takes all of the work (and the fear) away from HPC parallel programming
  with a proven and extremely tested library --- saving both a lot of time and a lot of money
  and simplifying C++ so much that you won't want to use Fortran - or even Java.

Automated Initialization (Heap Memory Allocation and Locking, CPU Locking, Thread Spawning, etc.)	Global (Template)	Processing, Synchronization (Self-Cleaning)
	Code (Template)

• You merely add to the Global(s) (Template), pick any Queue(s)
  and Execute your Code (another Template) in the thread,
• Application
• Status (w/ ErrorQ)
• ThreadStatus & ThreadParameters
• Initialization
• Global (per Thread) & GlobalPool (CPU, Memory, Sync)
• Global (per Thread) & (poss) GlobalPool (CPU, Memory, Sync)
• ...
• Global Bulk Data (CPU, Memory)
• Global Bulk Data (CPU, Memory)
• ...
• Queue (CPU, Memory, Sync, Bulk)
• Queue (CPU, Memory, Sync, Copy to Stack)
• ...
• Executive (Thread) (CPU, Stack Memory, your code)
• Executive (Thread) (CPU, Stack Memory, your code)
• ...
• for an Extremely Fast, Modular ('Plug-In' with 'fill-in-the-blank') theme
  with Socket Communication (no MPI required) for Clustered Systems.
• Now, the main program becomes extremely simple:

int main (int argc, char ** argv, char ** envp) {

Initialization initialization;

// synchronize iostream with stdio

ios::sync_with_stdio();

// Initialize program

application.init(argc, argv, envp);

// this while{} would allow for re-initialization

// WITH restarting the threads.

while (true) {

// Initialize threads

initialization.run();

// if REINITIALIZE, we could remain in this while{},

// completely restarting the threads and all init() routines.

if (application.InitializationState_ == TERMINATE) {

return 0;

} // end if (application...

} // end while (true...

}

Example Assuming Eight (8) Threads:

Global Data
Global Pool
Action Queue	Action Queue	Action Queue	Action Queue	Action Queue	Action Queue	Action Queue	Action Queue
Thread, Global	Thread, Global	Thread, Global	Thread, Global	Thread, Global	Thread, Global	Thread, Global	Thread, Global
Each Thread waits on the Action Queue for instructions. As all eight (8) threads then proceed with their portion of the Global Data to process, they then wait on the Synchronizer in the Global Pool (or many other locations) for the other threads and at least one, but perhaps many more times as desired. You can then write to another Action Queue for another set of threads to continually process your workflow, or even accross a Socket to another Cluster. And, the Global Pool (or many other locations) provides a Read/Write Lock for thread-safe multi-threaded variable modifications.
All eight (8) Threads can act together or they could be split at any time into smaller groupings (or Pools), with one thread per group being the Leader. Multiple ‘Global Data’ (managed by a Queue) can be created to continually fill with information while working on any one at any given time. All Global Objects are placed permanently on the Heap (Shared Memory) during Initialization while all Copy Queues and Threads are placed in (or copied to) Stack Memory for greater speed. All memory is locked down local (as available) to any CPU for greater speed. And as this library is obviously optimized specifically too for speed, time is measure in nanoseconds.
Note that this library is being used by the United States Department of Defense for the National Missile Defense program towards stopping Global Thermal Nuclear War.

Email: Dennis Kennedy