Saturday, October 14, 2017

Digest for comp.programming.threads@googlegroups.com - 2 updates in 2 topics

Intelli2 <intelli2@mama.com>: Oct 13 07:59PM -0400

Hello..
 
 
Scalable counting networks for Delphi and FreePascal..
 
 
Author: Amine Moulay Ramdane
 
Description:
 
 
Counting networks are truly scalable and are a special type of balancer
networks which count.
 
They were first introduced by Aspnes, Herlihy, and Shavit in the
following paper:
 
James Aspnes, Maurice Herlihy, and Nir Shavit. 1994. Counting networks.
J. ACM 41, 5 (September 1994), 1020-1048.
 
This project's goal is to evalute the scalability of counting networks
in modern SMPs.
 
This is a port to Delphi and FreePascal of this project that implement
scalable counting networks:
 
https://github.com/stephentu/counting-networks
 
I have added to the above project a function called: get_tl_idx(), to
expose a thread local called tl_idx to be more useful.
 
You can download it from:
 
https://sites.google.com/site/aminer68/scalable-counting-networks-for-delphi-and-freepascal
 
 
Thank you,
Amine Moulay Ramdane.
Intelli2 <intelli2@mama.com>: Oct 13 06:39PM -0400

Hello,
 
 
ThreadpoolX that scales very well is here..
 
I have ported the scalable counting network algorithm to Delphi and
FreePascal, and i have used it inside my following ThreadpoolX engine,
and now it scales very well, here is the papers of the scalable counting
network algorithm:
 
http://people.csail.mit.edu/shanir/publications/AHS.pdf
 
and also read the following (the counting network is truly scalable,
please look at the graph inside the paper):
 
http://people.csail.mit.edu/shanir/publications/HLS.pdf
 
you have to look at my following Threadpool engine that scales very well
now, because it is very powerful now, here is what it supports:
 
- I have used scalable counting networks to make my Threadpool engine
scale very well.
 
- 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.
 
Please read the new HTML tutorial inside the zip.
You can download it from:
 
https://sites.google.com/site/aminer68/an-efficient-threadpool-engine-that-scales-very-well
 
and the one with priortities is here:
 
https://sites.google.com/site/aminer68/an-efficient-threadpool-engine-with-priorities-that-scales-very-well
 
And the Linux version is coming soon...
 
 
Thank you,
Amine Moulay Ramdane.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.programming.threads+unsubscribe@googlegroups.com.

No comments: