Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.pascal.misc > #2749

More about compile time and build time..

Show all headers | View raw

Hello..


I have just read the following:

The Rust Compilation Model Calamity

https://pingcap.com/blog/rust-compilation-model-calamity


So as you notice that the compile times of Rust are so bad.

More about compile time and build time..

Look here about Java it says:

"Java Build Time Benchmarks

I'm trying to get some benchmarks for builds and I'm coming up short via 
Google. Of course, build times will be super dependent on a million 
different things, but I'm having trouble finding anything comparable.

Right now: We've got ~2 million lines of code and it takes about 2 hours 
for this portion to build (this excludes unit tests).

What do your build times look like for similar sized projects and what 
did you do to make it that fast?"

Read here to notice it:

https://www.reddit.com/r/java/comments/4jxs17/java_build_time_benchmarks/


So 2 million lines of code of Java takes about 2 hours to build.


And what do you think that 2 millions lines of code takes
to Delphi ?

Answer: Just about 20 seconds.


Here is the proof from Embarcadero, read and look at the video to be 
convinced about Delphi:

https://community.idera.com/developer-tools/b/blog/posts/compiling-a-million-lines-of-code-with-delphi

C++ also takes "much" more time to compile than Delphi.


This is why i said previously the following:


I think Delphi is a single pass compiler, it is very fast at compile 
time, and i think C++ and Java and C# are multi pass compilers that are 
much slower than Delphi in compile time, but i think that the generated 
executable code of Delphi is still fast and is faster than C#.

And what about the Advantages and disadvantages of single and multi pass 
compiler?

And From Automata Theory we get that any Turing Machine that does 2 (or 
more ) pass over the tape, can be replaced with an equivalent one that 
makes only 1 pass, with a more complicated state machine. At the 
theoretical level, they the same. At a practical level, all modern 
compilers make only one pass over the source code. It typically 
translated into an internal representation that the different phases 
analyze and update. During flow analysis basic blocks are identified. 
Common sub expression are found and precomputed and results reused. 
During loop analysis, invariant code will be moved out the loop. During 
code emission registers are assigned and peephole analysis and code 
reduction is applied.

More about Delphi..

As you have noticed i am also using Delphi and Freepascal,
so read the following to know more about Delphi:

Delphi for iOS and Android: The Natives are restless

Delphi’s Strengths and Weaknesses

So what does all this mean for developers?  It means that Delphi has its 
strengths and weaknesses, and as long as you are aware of them, you can 
choose Delphi for the right jobs.

If you need cross-platform compatibility and want to deal with only one 
code base (mostly), Delphi is an excellent choice.  It provides nice 
abstractions of the OS and its services, a relatively pretty GUI 
library, and native (very fast) access to the CPU.  Delphi also has 
excellent DB connectivity, web services connectivity, and networking in 
general. This means Delphi is a good choice for:

- Enterprise developers, who want to provide mobile access and don’t 
really care about pixel-perfect look and feel

- Scientific and number crunching developers, who need fast processing 
and a way to nicely display their results

- Game developers, surprisingly enough, who want to develop 
cross-platform games which don’t have “native” interfaces anyway and 
where FMX can provide fast-enough graphics.  (In other words, not Madden 
level graphics but Angry Birds).

- “Light” Apps which don’t use a bazillion controls to interact with the 
user and don’t need “pixel-perfect” responsiveness

- Compelling apps where the user will forgive some idiosyncrasies 
because the app is so good.  I mention this because Delphi allows you to 
concentrate on the app.  Delphi provides the RAD and the cross-platform 
compatibility, you can concentrate on making the killer app.

Read more here:

http://riversoftavg.com/blogs/index.php/2013/09/28/delphi-for-ios-and-android-the-natives-are-restless/

Pascal still an advantage for some iOS, Android developers

Many developers wouldn't dream of developing in Delphi with iOS or 
Android in mind, but with cross-platform compilers, companies sitting on 
years of solid code may suddenly find themselves with a second wind.

Read more here:

https://www.zdnet.com/article/pascal-still-an-advantage-for-some-ios-android-developers/

NASA is also using Delphi, read about it here:

https://community.embarcadero.com/blogs/entry/want-moreexploration-40857


The European Space Agency is also using Delphi, read about it here:

https://community.embarcadero.com/index.php/blogs/entry/delphi-s-involvement-with-the-esa-rosetta-comet-spacecraft-project-1


More about Energy efficiency..

You have to be aware that parallelization of the software
can lower power consumption, and here is the formula
that permits you to calculate the power consumption of
"parallel" software programs:

Power consumption of the total cores =  (The number of cores) * ( 
1/(Parallel speedup))^3) * (Power consumption of the single core).


Also read the following about energy efficiency:

Energy efficiency isn’t just a hardware problem. Your programming
language choices can have serious effects on the efficiency of your
energy consumption. We dive deep into what makes a programming language
energy efficient.

As the researchers discovered, the CPU-based energy consumption always
represents the majority of the energy consumed.

What Pereira et. al. found wasn’t entirely surprising: speed does not
always equate energy efficiency. Compiled languages like C, C++, Rust,
and Ada ranked as some of the most energy efficient languages out there,
and Java and FreePascal are also good at Energy efficiency.

Read more here:

https://jaxenter.com/energy-efficient-programming-languages-137264.html

RAM is still expensive and slow, relative to CPUs

And "memory" usage efficiency is important for mobile devices.

So Delphi and FreePascal compilers are also still "useful" for mobile
devices, because Delphi and FreePascal are good if you are considering
time and memory or energy and memory, and the following pascal benchmark
was done with FreePascal, and the benchmark shows that C, Go and Pascal
do rather better if you’re considering languages based on time and
memory or energy and memory.

Read again here to notice it:

https://jaxenter.com/energy-efficient-programming-languages-137264.html


Embarcadero Launches LearnDelphi.org ...

As you have noticed , i am also programming in Delphi and Freepascal,
and now i will invite you to read the following news about Delphi:

Embarcadero Launches LearnDelphi.org, a Delphi-Centric Learning 
Ecosystem, to Promote Delphi Education

Read more here:

https://apnews.com/Business%20Wire/0524383998734d05a34d5900fdfa0058

And here is the new website of LearnDelphi.org:

https://www.learndelphi.org/

What about garbage collection?

Read what said this serious specialist called Chris Lattner:

"One thing that I don’t think is debatable is that the heap compaction
behavior of a GC (which is what provides the heap fragmentation win) is
incredibly hostile for cache (because it cycles the entire memory space
of the process) and performance predictability."

"Not relying on GC enables Swift to be used in domains that don’t want
it - think boot loaders, kernels, real time systems like audio
processing, etc."

"GC also has several *huge* disadvantages that are usually glossed over:
while it is true that modern GC's can provide high performance, they can
only do that when they are granted *much* more memory than the process
is actually using.  Generally, unless you give the GC 3-4x more memory
than is needed, you’ll get thrashing and incredibly poor performance.
Additionally, since the sweep pass touches almost all RAM in the
process, they tend to be very power inefficient (leading to reduced
battery life)."

Read more here:

https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160208/009422.html

Here is Chris Lattner's Homepage:

http://nondot.org/sabre/

And here is Chris Lattner's resume:

http://nondot.org/sabre/Resume.html#Tesla


This why i have invented the following scalable algorithm and its
implementation that makes Delphi and FreePascal more powerful:

My invention that is my scalable reference counting with efficient 
support for weak references version 1.38 is here..

Here i am again, i have just updated my scalable reference counting with 
efficient support for weak references to version 1.37, I have just added 
a TAMInterfacedPersistent that is a scalable reference counted version, 
and now i think i have just made it complete and powerful.

Because I have just read the following web page:

https://www.codeproject.com/Articles/1252175/Fixing-Delphis-Interface-Limitations

But i don't agree with the writting of the guy of the above web page, 
because i think you have to understand the "spirit" of Delphi, here is why:

A component is supposed to be owned and destroyed by something else, 
"typically" a form (and "typically" means in english: in "most" cases, 
and this is the most important thing to understand). In that scenario, 
reference count is not used.

If you pass a component as an interface reference, it would be very 
unfortunate if it was destroyed when the method returns.

Therefore, reference counting in TComponent has been removed.

Also because i have just added TAMInterfacedPersistent to my invention.

To use scalable reference counting with Delphi and FreePascal, just 
replace TInterfacedObject with my TAMInterfacedObject that is the 
scalable reference counted version, and just replace 
TInterfacedPersistent with my TAMInterfacedPersistent that is the 
scalable reference counted version, and you will find both my 
TAMInterfacedObject and my TAMInterfacedPersistent inside the 
AMInterfacedObject.pas file, and to know how to use weak references 
please take a look at the demo that i have included called example.dpr 
and look inside my zip file at the tutorial about weak references, and 
to know how to use delegation take a look at the demo that i have 
included called test_delegation.pas, and take a look inside my zip file 
at the tutorial about delegation that learns you how to use delegation.

I think my Scalable reference counting with efficient support for weak 
references is stable and fast, and it works on both Windows and Linux, 
and my scalable reference counting scales on multicore and NUMA systems,
and you will not find it in C++ or Rust, and i don't think you will find 
it anywhere, and you have to know that this invention of mine solves
the problem of dangling pointers and it solves the problem of memory 
leaks and my scalable reference counting is "scalable".

And please read the readme file inside the zip file that i have just 
extended to make you understand more.

You can download my new scalable reference counting with efficient 
support for weak references version 1.38 from:

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


Thank you,
Amine Moulay Ramdane.

Back to comp.lang.pascal.misc | Previous | Next | Find similar

Thread

More about compile time and build time.. World90 <d3@d3.d3> - 2020-10-12 14:07 -0400

csiph-web