Friday, August 24, 2018

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

Sky89 <Sky89@sky68.com>: Aug 23 06:47PM -0400

Hello..
 
My next software projects..
 
As you have noticed i have implemented graphical Winmenus, it is an
interesting Widget that i have designed myself, i will enhance it more,
but as also you have noticed that the zipfile of my Winmenus using
Wingraph contains my 64 bit windows executabe demo called real3d1.exe
that makes you take a look at my Winmenus widget and it contains a 3D
Opengl demo and other demos , please execute this real3d1.exe to look at
how powerful is my graphical program, i have also made Wingraph
compatible with FreePascal and Delphi including Delphi tokyo, so that
you will be able to prototype rapidly 3D "Opengl" graphical programs,
you can download my graphical Winmenus using wingraph from:
 
https://sites.google.com/site/scalable68/winmenus-using-wingraph
 
 
And as i will enhance soon my graphical Winmenus
Here is my next software projects that i will implement and "invent":
 
Here is my other software project for Delphi and FreePascal that i will
finish soon:
 
1- I will support async and await
 
2- I will support futures
 
3- I will support "scalable" Parallel Foreach with priorities that will
be very "powerful" using my "scalable" Threadpools with and without
priorities.
 
Here is my Threadpool with priorities that i have invented and that
scales very well (i have invented another "fully" scalable Threadpool
that is really powerful), read about it and download it from here:
 
https://sites.google.com/site/scalable68/an-efficient-threadpool-engine-with-priorities-that-scales-very-well
 
And here is my last project in FreePascal and Delphi(including Delphi
tokyo) that i have "invented", it is a "scalable" reference counting
with efficient support for weak references, you will not find it in C++
and you will not find it in Rust, read about it and download it from here:
 
https://sites.google.com/site/scalable68/scalable-reference-counting-with-efficient-support-for-weak-references
 
 
I have also "invented" my C++ synchronization objects library,
read about it and download it from here:
 
https://sites.google.com/site/scalable68/c-synchronization-objects-library
 
You have to understand my work..
 
I have invented many scalable algorithms and there implementations, here
is some of them that i have "invented":
 
1- Scalable Threadpools that are powerful
 
2- Scalable RWLocks of different sorts.
 
3- Scalable reference counting with efficient support for weak references
 
4- Scalable FIFO queues that are node-based and array-based.
 
5- My Scalable Varfiler
 
6- Scalable Parallel implementation of Conjugate Gradient Dense Linear
System Solver library that is NUMA-aware and cache-aware, and also a
Scalable Parallel implementation of Conjugate Gradient Sparse Linear
System Solver library that is cache-aware.
 
7- Scalable MLock that is a scalable Lock.
 
8- Scalable SeqlockX
 
 
And there is also "many" other scalable algorithms that i have "invented".
 
You can find some of my scalable algorithms and there implementations in
Delphi and FreePascal and C++ on my website here:
 
https://sites.google.com/site/scalable68/
 
What i am doing by "inventing" many scalable algorithms and there
implementations, is wanting to make "Delphi" much better and making
FreePascal on the "Delphi" mode much better, my scalable algorithms
and there implementations are like HPC(high performance computing,
and as you have noticed i said also:
 
You will ask why have i invented many scalable algorithms and
there implementations? because also my work will permit us also to
"revolutionise" science and technology because it is HPC(high
performance computing), this is why i will also sell some of my scalable
algorithms and there implementations to companies such as Google or
Microsoft or Embarcadero.
 
Also HPC has revolutionised the way science is performed. Supercomputing
is needed for processing sophisticated computational models able to
simulate the cellular structure and functionalities of the brain. This
should enable us to better understand how our brain works and how we can
cope with diseases such as those linked to ageing and to understand more
about HPC, read more here:
 
https://ec.europa.eu/digital-single-market/en/blog/why-do-supercomputers-matter-your-everyday-life
 
And i think i will "sell" "some" of my scalable algorithms and there
implementations to Google or to Microsoft or to Embarcadero.
 
I will also enhance my Parallel archiver and my Parallel compression
Library that are powerful and that work with both C++Builder and Delphi
and to perhaps sell them to Embarcadero that sells Delphi and C++Builder.
 
About portability of my software projects
 
I have thought more, and as you have noticed i have written Intel
assembler routines for 32 bit and 64 bit for atomically incrementing and
and for atomically CompareExchange etc. so now they are working with x86
AMD and Intel processors for 32 bit and 64 bit, but i will soon make my
Delphi and FreePascal and C++ libraries portable to the other CPUs like
ARM(for Android) etc. for that i will use the following Delphi methods
for Delphi:
 
http://docwiki.embarcadero.com/Libraries/XE8/en/System.SyncObjs.TInterlocked.CompareExchange
 
and
 
http://docwiki.embarcadero.com/Libraries/Tokyo/en/System.SyncObjs.TInterlocked.Exchange
 
 
And I will use the same functions that you find inside FreePascal, here
they are:
 
https://www.freepascal.org/docs-html/rtl/system/interlockedexchange64.html
 
and
https://www.freepascal.org/docs-html/rtl/system/interlockedexchange.html
 
and
 
https://www.freepascal.org/docs-html/rtl/system/interlockedcompareexchange.html
 
and
 
https://www.freepascal.org/docs-html/rtl/system/interlockedcompareexchange64.html
 
 
I will use them inside my scalable lock that is called scalable MLock
that i have "invented", so that it will be portable, here it is:
 
https://sites.google.com/site/scalable68/scalable-mlock
 
 
And when my scalable MLock will become portable on Delphi and FreePascal
i will port with it all my other libraries that uses atomically
increment and decrement etc., so my libraries will become portable to
the other CPUs like ARM for Android etc., so i think you will be happy
with my work.
 
About Extreme Scaling in CAE Applications..
 
I have just read the following about Ansys company:
 
https://en.wikipedia.org/wiki/Ansys
 
 
Notice that Ansys develops and markets finite element analysis software
used to simulate engineering problems.
 
I think that i have thought about this, and i have "invented"
a Scalable Parallel C++ Conjugate Gradient Linear System Solver Library,
in fact it scales "very" well, my library contains a Scalable Parallel
implementation of Conjugate Gradient Dense Linear System Solver library
that is NUMA-aware and cache-aware, and it contains also a Scalable
Parallel implementation of Conjugate Gradient Sparse Linear
System Solver library that is cache-aware.
 
Sparse linear system solvers are ubiquitous in high performance
computing (HPC) and often are the most computational intensive parts in
scientific computing codes. A few of the many applications relying on
sparse linear solvers include fusion energy simulation, space weather
simulation, climate modeling, and environmental modeling, and finite
element method, and large-scale reservoir simulations to enhance oil
recovery by the oil and gas industry.
 
Conjugate Gradient is known to converge to the exact solution in n steps
for a matrix of size n, and was historically first seen as a direct
method because of this. However, after a while people figured out that
it works really well if you just stop the iteration much earlier - often
you will get a very good approximation after much fewer than n steps. In
fact, we can analyze how fast Conjugate gradient converges. The end
result is that Conjugate gradient is used as an iterative method for
large linear systems today.
 
You can download my Scalable Parallel C++ Conjugate Gradient Linear
System Solver Library from here:
 
https://sites.google.com/site/scalable68/scalable-parallel-c-conjugate-gradient-linear-system-solver-library
 
Read the following about Extreme Scaling in CAE Applications, this is
why i have invented my Scalable Parallel C++ Conjugate Gradient Linear
System Solver Library that scales very well:
 
https://www.cray.com/blog/extreme-scaling-in-cae-applications/
 
 
You can find some of my other software projects here:
 
https://sites.google.com/site/scalable68/
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: Aug 23 05:15PM -0400

Hello..
 
 
My Universal Scalability Law for Delphi and FreePascal was updated to
version 3.21
 
Now i have specified that:
 
Coefficient Alpha is: the contention
 
And
 
Coefficient Beta is: the coherency.
 
Contention and coherency are measured as the fraction of the sequential
execution time. A value of 0 means that there is no effect on
performance. A contention factor of 0.2, for instance, means that 20% of
the sequential execution time cannot be parallelized. A coherency factor
of 0.01 means that the time spent in the synchronization between each
pair of processes is 1% of the sequential execution time.
 
And i have included a 32 bit and 64 bit windows executables called
usl.exe and usl_graph.exe inside the zip, please read the readme file
to know how to use it, it is a very powerful tool.
 
You can download and read about my Universal Scalability Law for Delphi
and FreePascal version 3.21 from:
 
https://sites.google.com/site/scalable68/universal-scalability-law-for-delphi-and-freepascal
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: Aug 23 04:39PM -0400

Hello..
 
 
More precision:
 
My Winmenus using wingraph was updated to version 1.02
 
Now it is both compatible with Delphi and with FreePascal, now
it works with Delphi tokyo, but there is only one difference between
Delphi and FreePascal, the double click with the left button of the
mouse of freepascal is replaced in Delphi with a one click with the
middle button of the mouse to avoid a problem.
 
You can now download both the zipfiles for FreePascal and for Delphi.
 
You can download my Winmenus using wingraph from:
 
https://sites.google.com/site/scalable68/winmenus-using-wingraph
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: Aug 23 04:27PM -0400

Hello..
 
 
My Winmenus using wingraph was updated to version 1.02
 
Now it is both compatible with Delphi and with FreePascal, now
it works with Delphi tokyo, but there is only one difference between
Delphi and FreePascal, the double click wit a mouse of freepascal is
replaced with a one click with the middle mouse in Delphi to avoid a
problem.
 
You can now download both the zipfiles for FreePascal and for Delphi.
 
You can download my Winmenus using wingraph from:
 
https://sites.google.com/site/scalable68/winmenus-using-wingraph
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: Aug 23 02:06PM -0400

Hello,
 
 
I have implemented Winmenus using wingraph, this one is graphical, i
have also included an Opengl demo and other demos , just execute the
real3d1.exe executable inside the zipfile to see how it is powerful, i
will soon enhance much more my Winmenus.
 
WinMenus using wingraph version 1.0
 
Author: Amine Moulay Ramdane
 
Description:
 
Drop-Down Menu widget using the Object Pascal wingraph unit , it
supports keyboard and mouse. Please look at the real3d1.pas demo inside
the zip file, i have included its 64 bit executable, please run it and
see(please double click with the mouse on the items to execute and
click on the middle mouse to stop the demo, and press escape to exit
from the demo).
 
And use the 'Up' and 'Down' and 'PageUp and 'PageDown' to scroll the menu..
And 'Enter' to select an item from the menu..
And the 'Esc' on the keyboard to exit from the menu..
 
and right arrow and left arrow to scroll on the left or on the right of
the menu
 
Winmenus is event driven, i have to explain it more to you to understand
more...
 
At first you have to create your Widget menu by executing something like
this:
 
Menu1:=TMenu.create(5,5);
 
This will create a Widget menu at the coordinate (x,y) in characters = (5,5)
 
After that you have to set your callback function, cause my Winmenus is
event driven, so you have to add an item with AddItem() and set the
callback function at the same time, like this:
 
AddItem('First 3D opengl demo',test1);
 
test1 will be the callback function.
 
When you execute menu1.execute(false) with a parameter equal to false my
Winmenus widget will draw your menu without waiting for your input and
events, when you set the parameter of the execute() method to true it
will wait for your input and events, if the parameter of the execute
method is true and the returned value of the execute method ctExit that
means you have pressed on the Escape key to exit.
 
 
You can download my Winmenus from:
 
https://sites.google.com/site/scalable68/winmenus-using-wingraph
 
Language: FPC Pascal v2.2.0+ / Delphi 7+: http://www.freepascal.org/
 
Operating Systems: Windows..
 
Required FPC switches: -O3 -Sd -dFPC -dFreePascal
 
-Sd for delphi mode....
 
Required Delphi switches: -DMSWINDOWS -$H+
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: Aug 23 09:47AM -0400

Hello,
 
Read this:
 
 
D-Wave Computer Can Accurately Simulate Quantum Systems, Research Finds
 
Read more here:
 
https://www.tomshardware.com/news/d-wave-quantum-systems-research,37675.html
 
 
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.
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)