Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.programming.threads > #4437

Here is my other invention..

Show key headers only | View raw

Hello..


Here is my other invention..

You know me that i am an "inventor" of many scalable algorithms and 
there implementations, now here is my other "invention" that is an 
efficient Threadpool with priorities that scales very well, it is as it 
is fully scalable, because work stealing is "rare", it is much more 
scalable than the one of Microsoft,  here it is read about it and 
download it(it comes with a FreePascal versions for Windows and Linux 
and with a Delphi version for Windows) and it comes with an HTML 
tutorial inside the zip file:

An efficient Threadpool engine with priorities that scales very well

version 3.2

Author: Amine Moulay Ramdane

Description:

Efficient Thread Pool Engine with priorities that scales very well. I 
have updated my efficient Threadpool engine with priorities and my 
Threadpool engine to version 3.2, i have come up with a new algorithm 
that is more optimized and that scales very well.

The following have been added to my efficient Threadpool engine:

- I have used scalable counting networks to make my Threadpool engine 
scales very well.

- You can give the following priorities to jobs:

LOW_PRIORITY

NORMAL_PRIORITY

HIGH_PRIORITY

- The worker threads enter in a wait state when there is no job in the 
concurrent FIFO queues - for more efficiency -

- You can distribute your jobs to the worker threads and call any method 
with the threadpool's execute() method.

- It uses work-stealing to be more efficient.

- You can configure it to use stacks or FIFO queues , when you use 
stacks it will be cache efficient.

- Now it can use processor groups on windows, so that it can use more 
than 64 logical processors and it scales well.

- Now it distributes the jobs on multiple FIFO queues or stacks so that 
it scales well.

- You can wait for the jobs to finish with the wait() method.

- It's NUMA-aware and NUMA efficient.

- And it is portable to many operating systems.

- Uses O(1) complexity on enqueue and O(3) worst case complexity on dequeue.

And look at the ThreadPoolExecutor Class of Java, look for example at 
the awaitTermination() method, it says:

---

boolean awaitTermination(long timeout, TimeUnit unit)

Blocks until all tasks have completed execution after a shutdown 
request, or the timeout occurs, or the current thread is interrupted, 
whichever happens first.

--

read more here:

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ThreadPoolExecutor.html#method.summary

Did you notice ?

In Java when you wait for the tasks you have to wait for "ALL" the 
tasks, and that's not efficient , and if you want to use the object from 
multiple threads i think it will have the same effect, you can avoid 
some of the problems by using many objects of the ThreadPoolExecutor 
class but this will take ressources and this will cause more and more 
context switches and that's bad, i think C# has the same problem, other 
than that Java and C# don't support priorities, it means that you can 
not give priorities to tasks/jobs, like high or normal or low, and 
that's not good for games and other applications where you have to use 
priorities even if the system is not a realtime system, this is why i 
have decided to implement my efficient Threadpool engine version 3.2 
that supports those characteristics and that scales well, so that you 
can create a child object of the Threadpool class that will use the same
worker threads and that will wait only for the tasks that you will add 
with the execute() method , and also my efficient Threadpool engine 
supports 3 priorities, High and normal and low, that's where my 
efficient Threadpool engine comes in hand and that's where it's 
efficient. Hope you will like it.

Please read the HTML tutorial inside the zip.

More precision about my efficient Threadpool that scales very well, my 
Threadpool is much more scalable than the one of Microsoft, in the 
workers side i am using scalable counting networks to distribute on the 
many queues or stacks, so it is scalable on the workers side, on the 
consumers side i am also using lock striping to be able to scale very 
well, so it is scalable on those parts, on the other part that is work 
stealing, i am using scalable counting networks, so globally it scales 
very well, and since work stealing is "rare" so i think that my 
efficient Threadpool that scales very well is really powerful, and it is 
much more optimized and the scalable counting networks eliminate false 
sharing, and it works with Windows and Linux.

You have to know that to enlarge the stack of the worker threads of the 
Threadpool that use TThread, you have to set the stack size for the 
executable.


You can dowload it from:

https://sites.google.com/site/scalable68/an-efficient-threadpool-engine-with-priorities-that-scales-very-well

Look into defines.inc there is many options:

{$DEFINE CPU32} and {$DEFINE Windows32} for 32 bit systems

{$DEFINE CPU64} and {$DEFINE Windows64} for 64 bit systems

Look at test.pas demo inside the zip file...

Language: FPC Pascal v2.2.0+ / Delphi 5+: http://www.freepascal.org/

Operating Systems: Win , Linux and Mac (x86).

Required FPC switches: -O3 -Sd

-Sd for delphi mode....

Required Delphi switches: -DDelphi -DMSWINDOWS -$H+

For Delphi XE-XE7 use the -DXE switch

{$DEFINE CPU32} and {$DEFINE Windows32} for 32 bit systems

{$DEFINE CPU64} and {$DEFINE Windows64} for 64 bit systems




Thank you,
Amine Moulay Ramdane.

Back to comp.programming.threads | Previous | Next | Find similar | Unroll thread

Thread

Here is my other invention.. Sky89 <Sky89@sky68.com> - 2018-07-08 20:32 -0400

csiph-web