Monday, May 9, 2016

Digest for comp.lang.c++@googlegroups.com - 25 updates in 9 topics

bleachbot <bleachbot@httrack.com>: May 09 03:16AM +0200

bleachbot <bleachbot@httrack.com>: May 09 03:39AM +0200

bleachbot <bleachbot@httrack.com>: May 09 03:57AM +0200

bleachbot <bleachbot@httrack.com>: May 09 06:27PM +0200

bleachbot <bleachbot@httrack.com>: May 09 06:35PM +0200

bleachbot <bleachbot@httrack.com>: May 09 06:41PM +0200

bleachbot <bleachbot@httrack.com>: May 09 07:34PM +0200

bleachbot <bleachbot@httrack.com>: May 09 08:14PM +0200

bleachbot <bleachbot@httrack.com>: May 09 08:17PM +0200

Ramine <ramine@1.1>: May 09 02:18PM -0700

Hello.......
 
 
Look at this Asymmetric rw_mutex with atomic-free fast-path for readers
by Dmitry Vyukov:
 
https://groups.google.com/forum/#!topic/lock-free/Hv3GUlccYTc
 
About my scalable Asymmetric Distributed Reader-Writer Mutex
 
My scalable Asymmetric Distributed Reader-Writer Mutex and its
implementation doesn't use epoch detection logic, and it doesn't use any
atomic operations and/or StoreLoad style memory barriers on the reader
side,and it uses a distributed technic, and it is FIFO fair on the
writer side and FIFO fair on the Reader side , and it is of course
Starvation-free, so it is suitable for realtime critical systems, and
the simplicity of use by users of the implementation of this my
new algorithm makes it more suitable that the much harder approach of RCU.
 
You can download my new and extended C++ synchronization objects library
from:
 
https://sites.google.com/site/aminer68/c-synchronization-objects-library
 
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <ramine@1.1>: May 09 02:16PM -0700

Hello...
 
 
Look at this Asymmetric rw_mutex with atomic-free fast-path for readers
by Dmitry Vyukov:
 
https://groups.google.com/forum/#!topic/lock-free/Hv3GUlccYTc
 
 
My Asymmetric Distributed Reader-Writer Mutex and its implementation
doesn't use epoch detection logic, and it doesn't use any atomic
operations and/or StoreLoad style memory barriers on the reader side,
and it uses a distributed technic, and it is FIFO fair on the writer
side and FIFO fair on the Reader side , and it is of course
Starvation-free, so it is suitable for realtime critical systems, and
the simplicity of use by users of the implementation of this my
new algorithm makes it more suitable that the much harder approach of RCU.
 
You can download my new and extended C++ synchronization objects library
from:
 
https://sites.google.com/site/aminer68/c-synchronization-objects-library
 
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <ramine@1.1>: May 09 12:36PM -0700

Hello........
 
 
My new algorithm that looks like RCU is here, it doesn't use
any atomic operations and/or StoreLoad style memory barriers
on the reader side, and it is finally implemented, you can download it
from here:
 
https://sites.google.com/site/aminer68/scalable-distributed-reader-writer-mutex
 
 
It is not the version 1 based on Dmitry Vyukov ,
but it is the version 2 that is own algorithm,
look at my version 2 algorithm implementation inside
DRWLOCK.pas source code.
 
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <ramine@1.1>: May 09 12:42PM -0700

On 5/9/2016 12:36 PM, Ramine wrote:
 
> https://sites.google.com/site/aminer68/scalable-distributed-reader-writer-mutex
 
> It is not the version 1 based on Dmitry Vyukov ,
> but it is the version 2 that is own algorithm,
 
I mean: but it is the version 2 that is my own algorithm.
 
 
Ramine <ramine@1.1>: May 09 01:35PM -0700

Hello....
 
To compile test1.pas example that uses my powerful Scalable Asymmetric
Distributed Reader-Writer Mutex, please uncomment define option
"version1" inside defines1.inc and comment the define option
"version2" inside defines1.inc
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <ramine@1.1>: May 09 12:29PM -0700

Hello......
 
 
My C++ synchronization objects library was extended...
 
My new algorithm that looks like RCU is here, i have added
my scalable asymmetric DRWLock that doesn't use any atomic operations
and/or StoreLoad style memory barriers on the reader side, so it look
like RCU, and it is fast. This scalable Asymmetric Distributed
Reader-Writer Mutex is FIFO fair on the writer side and FIFO fair on the
reader side and of course it is starvation-free and it does spin-wait,
and i have addded my scalable asymmetric DRWLockX that doesn't use any
atomic operations and/or StoreLoad style memory barriers on the reader
side, so it look like RCU, and it is fast. This scalable Asymmetric
Distributed Reader-Writer Mutex is FIFO fair on the writer side and FIFO
fair on the reader side and of course it is starvation-free, and it does
not spin-wait, but it waits on Event objects and my
SemaMonitor, so it is energy efficient.
 
 
You can download my new and extended C++ synchronization objects library
from:
 
https://sites.google.com/site/aminer68/c-synchronization-objects-library
 
 
Author: Amine Moulay Ramdane
 
Email: aminer@videotron.ca
 
Description:
 
This library contains seven synchronization objects, first one is my
scalable SeqlockX that is a variant of Seqlock that eliminates the
weakness of Seqlock that is "livelock"of the readers when there is more
writers, and second is my scalable MLock that is a scalable
lock , and third is my SemaMonitor that combines all characteristics
of a semaphore and an eventcount and also a windows
Manual-reset event and also a windows Auto-reset event, and fourth
is my scalable DRWLock that is a scalable reader-writer lock that is
starvation-free and it does spin-wait, and five is is my scalable
DRWLockX that is a scalable reader-writer lock that is
starvation-free and it doesn't spin-wait, but it waits on the Event
objects and my SemaMonitor, so it is energy efficient, and six one is
my scalable asymmetric DRWLock that doesn't use any atomic operations
and/or StoreLoad style memory barriers on the reader side, so it look
like RCU, and it is fast. This scalable Asymmetric Distributed
Reader-Writer Mutex is FIFO fair on the writer side and FIFO fair on the
reader side and of course it is starvation-free and it does spin-wait,
and seven one is my scalable asymmetric DRWLockX that doesn't use any
atomic operations and/or StoreLoad style memory barriers on the reader
side, so it look like RCU, and it is fast. This scalable Asymmetric
Distributed Reader-Writer Mutex is FIFO fair on the writer side and FIFO
fair on the reader side and of course it is starvation-free, and it does
not spin-wait, but it waits on Event objects and my
SemaMonitor, so it is energy efficient.
 
If you take a look at the zip file , you will notice that it contains
the DLLs Object pascal source codes, to compile those dynamic link
libraries source codes you will have to download my SemaMonitor Object
pascal source code and my SeqlockX Object pascal source code and my
scalable MLock Object pascal source code and my scalable DRWLock Object
pascal source code from here:
 
https://sites.google.com/site/aminer68/
 
I have compiled and included the 32 bit and 64 bit windows Dynamic Link
libraries inside the zip file, if you want to compile the dynamic link
libraries for Unix and Linux and OSX on (x86) , please download the
source codes of my SemaMonitor and my scalable SeqlockX and my scalable
MLock and my scalable DRWLock and compile them yourself.
 
My SemaMonitor of my C++ synchronization objects library is
easy to use, it combines all characteristics of a semaphore and an
eventcount and also a windows Manual-reset event and also a windows
Auto-reset event, here is its C++ interface:
 
class SemaMonitor{
public:
SemaMonitor(bool state, long2 InitialCount1=0,long2
MaximumCount1=INFINITE);
~SemaMonitor();
 
void wait(unsigned long mstime=INFINITE);
void signal();
void signal_all();
void signal(long2 nbr);
void setSignal();
void resetSignal();
long1 WaitersBlocked();
};
 
So when you set the first parameter that is state of the constructor to
true. it will add the characteristic of a Semaphore to the to the
Eventcount, so the signal will not be lost if the threads are not
waiting for the SemaMonitor objects, but when you set the first
parameter of the construtor to false, it will not behave like a
Semaphore because if the threads are not waiting for the SemaCondvar or
SemaMonitor the signal will be lost..
 
the parameters InitialCount1 and MaximumCount1 is the semaphore
InitialCount and MaximumCount.
 
The wait() method is for the threads to wait on the SemaMonitor
object for the signal to be signaled.
 
and the signal() method will signal one time a waiting thread on the
SemaMonitor object.
 
the signal_all() method will signal all the waiting threads on the
SemaMonitor object.
 
the signal(long2 nbr) method will signal nbr number of waiting threads
 
the setSignal() and resetSignal() methods behave like the windows Event
object's methods that are setEvent() and resetEvent().
 
and WaitersBlocked() will return the number of waiting threads on
the SemaMonitor object.
 
As you have noticed my SemaMonitor is a powerful synchronization object.
 
Please read the readme files inside the zip file to know more about them..
 
Language: GNU C++ and Visual C++ and C++Builder
 
Operating Systems: Windows, Linux, Unix and OSX on (x86)
 
 
 
Thank you,
Amine Moulay Ramdane.
Juha Nieminen <nospam@thanks.invalid>: May 09 06:16AM

> Noah built a quality vessel/ark with G-d's help. I'm not
> surprised it is difficult to duplicate it today even with
> modern woodcraft.
 
Isn't it curious how your god is so impotent that he needed the aid of
a human being to save the animals. He couldn't just snap his fingers
and make it happen. He could break the laws of physics and build a ship
that's a physical impossibility, but saving the animals himself was too
much. Because reasons.
 
--- news://freenews.netfront.net/ - complaints: news@netfront.net ---
Wouter van Ooijen <wouter@voti.nl>: May 09 08:41AM +0200


> I'm okay with having neighbors that don't believe the same as me.
 
>> Wouter "objects? No thanks!" van Ooijen
 
> What does that mean?
 
Google is your friend.
 
Wouter
"Fred.Zwarts" <F.Zwarts@KVI.nl>: May 09 10:04AM +0200

"Wouter van Ooijen" schreef in bericht
news:57230ec9$0$4287$e4fe514c@newszilla.xs4all.nl...
>is made of cedar and pine and was built atop a steel barge ..."
 
>So even at half the size and with modern woodcraft, they didn't try to
>built it from wood. It is essentially a big cabin on top of a steel ship.
 
As I understood it, the main reason to build it on top of a steel barge,
were the safety regulations of the government. Maybe Noah worked under a
government with different safety regulations. :)
scott@slp53.sl.home (Scott Lurndal): May 09 03:06PM


>> So even at half the size and with modern woodcraft, they didn't try to
>> built it from wood. It is essentially a big cabin on top of a steel ship.
 
>Noah built a quality vessel/ark with G-d's help.
 
But, you have no proof nor evidence that such as
vessel was ever actually built.
 
> I'm not
>surprised it is difficult to duplicate it today even with
>modern woodcraft.
 
Physics precludes it. It also precludes the noted effects
of 40 days of rain (unless the icecaps completely melted, which
physics says would take millenia).
 
 
>> important. Living next to a (different-)religious neighbour is to be
>> preferred over being dead on the bottom of a sea.)
 
>I'm okay with having neighbors that don't believe the same as me.
 
So why do you want to leave minnesota?
Juha Nieminen <nospam@thanks.invalid>: May 09 06:28AM

> , info_( text_buffer_.handle )
> , text_buffer_activation_( text_buffer_.handle )
> {
 
That's some of the most confusing code I have seen in a long while.
 
I that even supposed to be standard C++? I suppose that if Impl() is
a precompiler macro hiding some extra code, you *could* make that
compile as C++, but...
 
--- news://freenews.netfront.net/ - complaints: news@netfront.net ---
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: May 09 04:20PM +0200

On 09.05.2016 08:28, Juha Nieminen wrote:
 
> I that even supposed to be standard C++? I suppose that if Impl() is
> a precompiler macro hiding some extra code, you *could* make that
> compile as C++, but...
 
It's called a "memory initializer list".
 
Any good introductory book explains it.
 
If your book doesn't, then perhaps take a look at C++ book list at Stack
Overflow, <url:
http://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list>.
 
 
Cheers & hth.,
 
- Alf
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: May 09 04:22PM +0200

On 09.05.2016 16:20, Alf P. Steinbach wrote:
>> a precompiler macro hiding some extra code, you *could* make that
>> compile as C++, but...
 
> It's called a "memory initializer list".
 
/member/ initializer list, sorry.
 
It's not the first time that that word substitution has happened to me. :(
 
It's probably like a melody that gets stuck in one's brain, difficult to
get rid of.
 
 
 
Paul <pepstein5@gmail.com>: May 09 02:18AM -0700

The following (incomplete) code compiles fine and runs as expected when obvious modifications are made. However, I haven't found anything explicitly saying that it's ok to do this. How can I be sure there's no issue with converting set<int>::difference_type to int?
Thanks,
 
Paul
 
std::set<int> x{5,3};
int y = std::distance(x.begin(), x.find(5));
std::cout << y;
Ben Bacarisse <ben.usenet@bsb.me.uk>: May 09 11:31AM +0100


> The following (incomplete) code compiles fine and runs as expected
> when obvious modifications are made.
 
I get a warning that converting to int may alter the value (the two
types are different sizes on my system).
 
 
> std::set<int> x{5,3};
> int y = std::distance(x.begin(), x.find(5));
> std::cout << y;
 
I don't think there is one. You could hope that a compiler will tell
you and the everyone using your code will pay heed to and such messages.
Or you could check the size or, more accurately, the range of the two
types but that would be very fussy. What's wrong with using the right
type off the bat:
 
std::set<int> x{5,3};
auto y = std::distance(x.begin(), x.find(5));
std::cout << y;
 
?
 
--
Ben.
Ramine <ramine@1.1>: May 08 09:58PM -0700

Hello........
 
About my new scalable synchronization algorithm that i have
talked to you just before...
 
I will implement it with FreePascal compiler and the Delphi compiler,
and compile it use this implementation as a Dynamic Link library
in the C++ side, as i have done it with my C++ synchronization objects
library, because you have to underatand me Sir and Madam, since
C++ uses a weak memory model even on x86, this is error prone, so since
FreePascal compiler and Delphi compiler don't reorder loads and stores
on x86 , this has facilitate the reasoning about sequential consistency,
this is why i have done it this way in C++ using a Dynamic Link Library
compiled with FreePascal compiler that contains
the implementation of my algorithms, this is much safer than the C++ way.
 
 
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.lang.c+++unsubscribe@googlegroups.com.

No comments: