4.1 Runtime

Zoltan changed the way objects are allocated: heap objects are allocated with GC descriptors which describe which fields are holding object references and which do not. This speeds up collections and decreases memory usage since fewer objects are mistakenly retained.

The synchronized attribute is now supported.

4.2 ASP.NET

The ASP.NET code generator uses CodeDom now so, ideally, once we have mbas working and someone implements an ICodeCompiler and a CodeDomProvider for VB.NET we will support VB.NET in aspx pages.

4.3 C# Compiler

Many bugs have been fixed, and various speed improvements added. Zoltan added a change to reduce memory consumption, which reduced the compilation times. A cache that was underutilized has been fully activated, and the total speedup is 40%. Now MCS bootstraps itself in 6.3 seconds on a 1.8GHz Mobile P4.

Iterators in classes are supported now. This is a feature from the upcoming C# 2.0 release, it has not been wildly tested. To use iterators, pass the -v2 flag to the compiler. Notice that code that uses iterators will not compile with the current Microsoft compiler.

Iterators were prototyped for C# by Todd Proebsting, and they vastly simplify the implementation of enumerators in classes. Instead of being a tedious task, the results is that you can not wait to add enumerable support to the simplest of your classes.

Lluis continues to improve the Remoting infrastructure:

Implemented support for Contexts and ContextBoundObjects, including all context message sinks.

Support for interfaces and abstract classes in proxies.

The TCP channel and the binary formatter are now compatible with MS.NET.

OneWay methods are now working.

4.5 XML

The first implementation of XML deserialization has been done. It's not complete but XmlSerializer has now become somewhat symmetric.

Mono now ships Atsushi's RELAX NG validating XmlReader for XML (namespace: Commons.Xml.Relaxng). This is also the first XML validation engine for Mono.

Dogfooding-wise: We are using a Relax-NG schema and a simple program to validate our documentation now.

XmlTextReader has many improvements. XmlTextReader now can parse a supplied inline or external DTD (only infiles for now). It is also capable of auto encoding detection for its input.

XmlNodeReader has also improved to be compatible with XmlTextReader.

Alan added support for passing arguments to XSLT transformations

4.6 Windows.Forms

Alan added support for two Chinese encodings: Big5 and GB2312.

Duncan has been working on getting our CultureInfo completed. Currently we have checked in stubs for various XML files that describe the various characteristics of the CultureInfo. Currently they all contain the information for English, so we will need people to help provide translations and localization to these files.

4.8 New Code Generation Engine

This release contains the new code generation engine that Dietmar and Paolo have been working on for the past seven months. This new code generator can be used both as a just-in-time compiler or a CIL pre-compiler.

The new engine had a number of goals:

• Simplify porting the JIT engine.
• Provide a solid framework for implementing advanced optimizations in the JIT engine.
• Support ahead-of-time compilation (precompilation).

The new code generator replaces `mono' as our JIT engine. The old JIT engine is still distributed as `oldmono', but will be phased out.

In JIT mode, you have to run it like this:

	mono program.exe

In pre-compiler mode you first need to pre-compile your assembly. You do that by passing the --aot flag:

	mono --aot program.exe
	mono --aot mylibrary.dll

That will generate program.exe.so and mylibrary.dll.so respectively. These contain the precompiled code. Then to execute your precompiled binary, invoke the compiler like this:

	mono program.exe

The runtime will automatically pick up the precompiled binaries as long as they are in the same directory as the original assembly.

We are very happy with the new framework, because it is very modular, and it allows us to cleanly replace in the future components of it, if we choose to, or revamp components of it. The new code generator has also an SSA representation that is the foundation for plenty of optimizations today and in the future.

The following optimizations are implemented:

Branch optimizations, conditional moves, constant folding, constant propagation, copy propagation, dead code elimination, emit per-domain code, fast x86 FP compares, inline method calls, instruction scheduling, intrinsic method implementations, linear scan global reg allocation, loop related optimizations, peephole postpass, tail recursion and tail calls

A whitepaper on the internals of the new compilation engine is available on mono/mini/mini-doc.txt, if you are interested in understanding the new engine, this document is a good starting point.

The job of doing a good JIT requires a tradeoff between compilation speed and code generation quality. Some are computing-time expensive and some are cheap. In JIT mode, we only turn on a few optimizations, but you might want to turn them all on when doing pre-compilations (-O=all, see the mono man page for details).

The new JIT engine is closer to the spec so plenty of checks and tests that were not implemented before, are implemented now.

We can now focus on tuning the performance of the JIT engine

4.9 New Tools

Jackson continues work on our IL assembler. The IL assembler has most of the high-level features now, and 50% of the instruction set is handled. The next release should have a complete version.

Cesar continues work on our JScript compiler. All of the public class contracts in the Microsoft.JScript namespace are there, and the parser is mostly done. Work is underway to emit dynamic assemblies.

Work has begun on making the SOAP client support in Mono functional. To this end, we are starting to re-architect the XmlSerialization infrastructure, which had not been maintained for a while. We will be devoting significant effort in getting the Web services client functional now.

4.11 Mono Basic

Marco Ridoni has been making a lot of progress in Mono Basic. Also Rafael has added preprocessor support to it. Here is a full list of new features: Compound operators added