Hello,

More of my philosophy of why i have just invented a better Reader-Writer
Lock that is scalable and starvation-free and fair and reentrant
(recursive)..

I am a white arab, and i think i am smart since i have also
invented many scalable algorithms and algorithms..

Here is why i have invented a better Reader-Writer Lock that
is scalable, starvation-free and fair and reentrant (recursive),
and read look at my invention below:

Notice that the following PhD researcher says the following

"Until today, there is no known efficient reader-writer lock with
starvation-freedom guarantees"

Read more here:

http://concurrencyfreaks.blogspot.com/2019/04/onefile-and-tail-latency.html

And read the following paper:

Scalable Read-mostly Synchronization Using Passive Reader-Writer Locks

https://www.usenix.org/system/files/conference/atc14/atc14-paper-liu.pdf

You will notice that it has a first weakness that it is for TSO hardware
memory model and the second weakness is that the writers latency is very
expensive when there is few readers, and it can livelock because of the
writer preference, and it can have starvation.

And here is the other best scalable reader-writer lock invention of
Facebook:

SharedMutex is a reader-writer lock. It is small, very fast, scalable
on multi-core

Read here:

https://github.com/facebook/folly/blob/master/folly/SharedMutex.h

But you will notice that the weakness of this scalable reader-writer
lock is that the priority can only be configured as the following:

SharedMutexReadPriority gives priority to readers,
SharedMutexWritePriority gives priority to writers.

So the weakness of this scalable reader-writer lock is that
you can have starvation with it and you can have a livelock.

Bonita Montero a software engineer has just written to me the following
about my new invention below:

> Multiple reader, exlusive writer locks are *never* starvation-free.
> Readers can hold the lock infinitely and writers as well,

But i think she is not right, since this holding the lock infinitely is
not counted, since you have just to use it correctly and avoid this
case, so I think she is making a mistake and she is not understanding
what is that a Multiple-Readers-Exclusive-Writer Lock is
starvation-free, so what i mean by starvation-free is that in my
invention of my algorithm the readers don't starve the writers and the
writers don't starve the readers, and the writers don't starve and
readers don't starve, it is what we call starvation-free, and i think my
invention is scalable and starvation-free and fair.

And as you have just noticed i am also making public a number of my
scalable algorithms and algorithms and softwares as also open source
softwares and since i have just said in my new philosophy the following
about my new model that is called coopetition that is a well balancing
between cooperation and competition, since i think that economic
Liberalism or capitalism needs both competition and cooperation, since
we even need economic actors that share ideas across nations and
industries(and this needs globalization) that make us much more
creative, and i invite you to read the following important article so
that to notice it:

EU study on the impact of open source published

https://joinup.ec.europa.eu/collection/open-source-observatory-osor/news/report-open-source-driver-eus-digital-innovation

And read my following thoughts about Adam Smith and more so that to
notice it:

https://groups.google.com/g/alt.culture.morocco/c/ftf3lx5Rzxo

And read also here:

https://groups.google.com/g/alt.culture.morocco/c/YSaGSfcYmtc

Here is my new invention of a fast, and scalable and starvation-free and
fair and lightweight Multiple-Readers-Exclusive-Writer Lock called
LW_RWLockX, and now i have included two units that are called MREWEx and
LighweightMREWEx that include TMultiReadExclusiveWriteSynchronizer and
TLightweightMREW classes that are scalable and starvation-free and fair
since they are using my Scalable LW_RWLockX that is starvation-free and
fair, also BeginRead() and BeginWrite() of LightweightMREWEx are
reentrant (recursive), so in other words, if a thread already called
BeginWrite(), it can call BeginWrite() again and it will succeed and it
will not deadlock, and the same applies to BeginRead(), please take a
look at them inside the source code of my units.

You can download it from my website here:

https://sites.google.com/site/scalable68/new-variants-of-scalable-rwlocks

Here is also my way of how i am becoming rich:

First i want to say that i have passed four IQ tests and some of them
are certified and i have scored high, so i am highly smart, second,
my methodology is also that i am reading many PhD papers of researchers
and i am seeking the weaknesses of them, and i have found many
weaknesses on those PhD papers and from those weaknesses i have invented
many software scalable algorithms and algorithms and i have invented
some powerful software tools for parallelism etc., so i give you an
example of one of my invention that is: A Scalable reference counting
with efficient support for weak references, so that you understand that
i am truthful, here it is:

https://sites.google.com/site/scalable68/scalable-reference-counting-with-efficient-support-for-weak-references

But the truth is that i have invented many scalable algorithms such
as this one, and i have made public some of them. And here is another
example of how i am inventive and creative in operational research too,
i have just read the following book (and of other books like it) of a
PhD researcher about operational research and capacity planning, here
they are:

Performance by Design: Computer Capacity Planning by Example

https://www.amazon.ca/Performance-Design-Computer-Capacity-Planning/dp/0130906735

So i have just found that there methodologies of those PhD researchers
for the E-Business service don't work, because they are doing
calculations for a given arrival rate that is statistically and
empirically measured from the behavior of customers, but i think that it
is not correct, so i am being inventive and i have come with my new
methodology that fixes the arrival rate from the data by using an
hyperexponential service distribution(and it is mathematical) since it
is also good for Denial-of-Service (DoS) attacks and i will write a
powerful book about it that will teach my new methodology and i will
also explain the mathematics behind it and i will sell it, and my new
methodology will work for cloud computing and for computer servers.

You can read more about my education and my way of doing here:

And here is more proof of the fact that i have invented many scalable
algorithms and algorithms:

https://groups.google.com/g/comp.programming.threads/c/V9Go8fbF10k

Thank you,
Amine Moulay Ramdane.