. Net – what is the current performance of mono virtual machine?

The network is full of different types of performance tests for different languages, compilers and virtual machines However, few of these tests use real - world scenarios to test performance In addition, Google searches these benchmarks, which are usually only a few years old, because those have spent a lot of time collecting their links

Do any of you have any real understanding of the performance of different existing virtual machines? In addition, I especially want to know how mono's performance compares with Microsoft's Net and sun's Java, and how the performance of different virtual machines has evolved recently

Solution

Measuring performance is a complex matter In the past, when language testing for the same operating system, running the same hardware and a very limited set of libraries can create benchmarks that can give the linear measurement of the measurement system It allows people to evaluate things from zero to ten, absorb the results, and move quickly to the next topic

The situation of modern systems is becoming more and more complex because there are many variables to consider

At least in the case of mono, there are many variables that can play a role:

>Code:

>Quality of native code generated. > Speed at which native code is generated. > Memory required to generate and optimize code > code generator is multithreaded, and generated code is thread safe > it makes use of the specific functions of CPU at compile time or JIT time. > SIMD instructions can be used. > Whether the language itself maps neatly to multi-core platforms > whether the language provides enough parameters for the optimizer to automatically adjust the code (like FORTRAN)

>Memory management:

>Use garbage collection algorithm > does GC have multiple CPUs? Is it GC incremental or real-time? > Does it support thread local storage to improve performance? > It is precise, compacted, generational, conservative, and mixed

>API design:

Is API designed for latency or bandwidth > API supports automatic scaling to multiple CPUs Can you uninstall heavy work to GPU? Your API supports streaming media interfaces

All these things are so complicated that a simple 0 to 10 answer is difficult to give

If you want to divide languages in class, and you think a programmer with ability and performance perception, I will divide these worlds into these classes:

>Tier 1: professional manual assembly language > tier 2: static compilation, strongly typed language: C / C + + / Fortran / > Tier 3: Management / JIT language: Java / c# / Net / mono / boo / f# > layer 4: dynamic type / jited language: Google V8, ironpython, IronRuby > layer 5: pure interpreted language: Python, Perl > layer 6: pure interpreted language, with too many functions for your own good

However, these languages will not draw the whole picture. The API, host operating system and other facilities you will consume will have a significant impact on your results

For example, recently in mono, we added support for replacing mono's code engine with a more advanced and highly optimized engine (llvm engine) It turns out that the overhead of using llvm is worth the additional memory usage test is very difficult: there is no difference between desktop and web applications This may be because these are mostly I / O - bound applications

Using llvm is very useful for science and computing intensive applications, but in real life, it is no different from mono's default optimization settings

As for the details of mono: Although mono does use Boehm's GC, most people don't realize that Boehm can be configured in various ways The default layman configuration is really not very powerful, but it is suitable for everyone who wants fast GC Mono does not use Boehm in this mode. Mono widely configures Boehm to work in precise mode, while using thread local storage, multi-core GC and freeing memory to the operating system mode