Re how to write platform checks I do have a link to Kitware’s Wiki on from MySQL CMake wiki
(wanted to avoid repeating what is already documented somewhere else)
http://forge.mysql.com/wiki/CMake#For_Developers_:_how_to_write_platform_checks

The presence of particilar function in library is detected with CHECK_FUNCTION_EXISTS() , one can use CHECK_SYMBOL_EXIST() when looking for a macro or #define and CHECK_C{XX}_SOURCE_COMPILES when doing unusual things, e.g when functon has different signatures dependend on the OS (gethostbyname_r comes to mind).

Conditional builds:
In MySQL/CMake, we do conditional builds too, for example the ibmdb2 storage engine is only built if a header qlgusr.h is found (must be some i5 specific thing, but not on every box, and I never succeded in finding this header so far:)

The basic usage would be
CHECK_LIBRARY_EXISTS(foo HAVE_LIBFOO)
CHECK_INCLUDE_FILE(foo.h HAVE_FOO_H)

IF(HAVE_LIBFOO AND HAVE_FOO_H)
# do something
ENDIF()

Strict compiler flags
..on a variety of compilers is a great thing in drizzle, and I have not done that yet. This appears to be more political/organizational thing than it is technical. Checking compiler and adding a flag is easy, getting people to fix the warnings (we do have a lot of them shown in pushbuild) is harder. It has to be be a concerted effort, otherwise adding strict flags to something that already does not build cleanly warnings adds nothing but frustration.

Silent builds …
by default was always done CMake. The output is colorized, by default as well, looks nice.

Also, make dependencies between targets are working , by default.

I have no doubt that the CMake build system is probably better than MySQL’s autotools usage.

… and it really does suit the cross-platform problem…

One thing that may be worth adding to the MySQL CMake docs is how to put in a detection for a specific version of a library (or the presence of a particular function in a library).

Also how to have a plugin that is only built if certain dependencies are met, otherwise it isn’t.

e.g. for Drizzle we have some things (such as auth_pam) that are only built if you have PAM headers around. So, for example, if we were building on Win32, it would automagically not build the impossible.

In Drizzle, we also have (portable) code to put in strict compiler flags for a variety of compilers (and a way to disable it for specific files… e.g. generated ones that you can’t really fix).

Does CMake yet have the nice non-noisy build like new automake does?

The way I see it is that you can still get back all that information, you just have to say that you want the result and fetch it.

but I would be happy if someone unbiased can compare and contast MySQL’s build with CMake described here
http://forge.mysql.com/wiki/CMake to what you have with drizzle.

I expect the unbiased majority to prefer MySQL build then, I really do:)

Right, now that you mention it I see that the data in the table is presented in a really confusing way :-(

The numbers are time to process 2 billion elements in each thread. So with aligned words, two threads working on twice as many elements take twice the time, meaning no scalability (the reason for this is that memory bandwidth is the bottleneck, so adding threads gives no benefit).

The unaligned in contrast takes about the same time to process twice the amount of data in twice the number of threads, indicating linear scaling. The reason is that the data is smaller, so more elements can be processed with given memory bandwidth before hitting the limit.