Read again , i correct

[Ramine]

Hello..........

Here is how to implement pure functions of Haskel and Lisp in C++..

First you have to call a constructor that will put the global variables
as pointers for example in there respective queues..

And after that each method that wants to access a global variable will
take the global variable from the queue and copy it in a local
variable and work with it locally, and after that it will put
it back in its global queue , it's like message passing and
it's like pure functions with Mvars in Haskel and this mechanism is good
and will avoid race conditions in Object oriented programming.


For Deadlocks use this:

Use Lock Hierarchies to Avoid Deadlock

http://www.drdobbs.com/parallel/use-lock-hierarchies-to-avoid-deadlock/204801163


Thank you,
Amine Moulay Ramdane.

[Ramine]

Hello.....

About USL methodology here:

http://www.perfdynamics.com/Manifesto/USLscalability.html

I have understood the USL methodology..

USL methodology doesn't predict scalability because scalability
is dependant on the nature of data also.

But when you fix the data and test with USL methodology , you
can quantify the level of Contention (with strength α)
due to waiting or queueing for shared resources and the level of
Coherency (with strength β) due to the delay for data to become
consistent (or coherent) by virtue of point-to-point exchange,
and by forecasting on a fixed data you can have a better idea
of how your parallel system scales, so it is a powerful tool

Also i have easy the job for you by compiling my Universal Scalability
Law for Delphi and FreePascal programs to windows 32bit and 64bit
executables, they are really fantastic and powerful, they are GUI and
command line, please read about them and download them from here:

https://sites.google.com/site/aminer68/universal-scalability-law-for-delphi-and-freepascal