You will have to download, patch, and compile your own kernel because BFS is currently not part of the mainline kernel. The mainline kernel contains only one scheduler and is not meant to have multiple schedulers in the same codebase, or even on-the-fly switchable schedulers (it that's even something that could possibly be done). It would simply be too complicated, and not worth the effort.
So, in order to get BFS on your system:
The benefit of running BFS over CFS is very small though, especially with newer kernel versions. Keep in mind that CFS is constantly being improved.
The upstream kernels (referred, when we provide them, as mainline kernels) are simply the upstream kernel for the specified version, with a very few minor configuration changes added so that there is minimal issue using them on an Ubuntu Install.
The difference between these kernels and the one released for an Ubuntu version are numerous other configuration changes, source patches* and, in some cases, compiled in modules and hardware support.
Very little of the underlying code is different from upstream other than that noted above.
*: source patches are, in most cases, changes to the default behavior of the kernel. These are not limited to: blacklists, video quirks tables, built in modules, source changes that are not yet in Linus' tree or the stable queue quite yet etc.
Source patches are what the team uses to introduce configuration options that are required to support the vast array of released software for a specific version of Ubuntu. In many cases they are necessary for those applications to work properly. The fundamental difference between this and the upstream kernel is that the pure upstream kernel is not distribution specific.
Therefore, the configurations are not geared toward ensuring that certain applications work as expected. These configs exist to provide that level of changeability to the kernel for specific things. Additionally, the use of quirks allows us to identify hardware that requires specific things from the kernel that we can set once we detect them.
This is one of the major features of Linux and it is one of the reasons we have been able to run on so many diverse platforms over the years. There are times when the quirks and source patches cause issues between each other. During these times, we work to mitigate the problems with changes to underlying kernel behavior. In many cases these changes don't make it upstream until after the release due in very large part to the need to properly code the fix, document what was done, test the changes and conduct various other tests and stress testing.
In these cases, patches that are headed for upstream are carried as source patches in much the same way pre-stable and patches that are not yet in Linus' tree do. The link to the delta review spec should serve as a reference for what was reviewed for the current Natty release of the Ubuntu kernel.
Best Answer
Quick answer :
Explanations :
Since the schedulers are alone initiatives (aka not supported by the kernel) then the mere fact for including it would means to focus people in those schedulers (security patch, maintenance patch, speed up adaptation to new kernel releases, ...). It means financial investment for a project that is still unsure about it's existence in future.
They are still quite young. The best example is what is explained on the FAQ of BFS at "How scalable is it?".
Behind the lines of this part tells us that BFS has performance issues when you have a lot of logical CPU. This single point takes out for servers and high end PC (the number of 16 is given so it means that a simple 1000 USD server would have performance troubles with this). So you exclude Ubuntu Server of this patch, you also exclude physical bi CPU configurations that now easily reach this number.
Ubuntu can't reach masses if they use another scheduler. Scalability wins over performance.
As always, with many "if" ... :
In fact the best approach is the current one : Let the user apply the schedulers they want if they have the hardware and are interested in it.
Applying it may work better for some during some time (because, As I've said, the scalability is a big issue and the future will increment the number of processors). But will give serious troubles to others.
Extra Sources :
The link may not stay forever, here is an article I found about BFS on h-online. It's the most official I've found. However if you google hard you may find the real statement. I think it may be on kerneltrap.
See third paragraph of the phoenix title of the article. I'll quote it here in case the link dies :
Linus Torvalds Thread about it.