To change the Apache log rotate frequency, you would want to change the apache2 configuration file located under /etc/logrotate.d. Configurations located in this directory overrides the default settings in /etc/logrotate.conf (the configurations in /etc/logrotate.d are included in logrotate.conf)

Here’s what my settings look like (note that I had commented out compress option so that all the logs can be easily browsed):

/var/log/apache2/*.log {
daily
missingok
rotate 365
#compress
#delaycompress
notifempty
create 640 root adm
sharedscripts
postrotate
if [ -f "`. /etc/apache2/envvars ; echo ${APACHE_PID_FILE:-/var/run/apache2.pid}`" ]; then
/etc/init.d/apache2 reload > /dev/null
fi
endscript
}

Common problem

A common problem after changing the log rotate frequency is that the Apache logs do not appear to be rotating daily even though the configuration file had been changed correctly.

This seems to be a known issue with logrotate. If you read the manual for logrotate you’d see the following explanation:

-f, –force
Tells logrotate to force the rotation, even if it doesn’t think
this is necessary. Sometimes this is useful after adding new
entries to a logrotate config file, or if old log files have
been removed by hand, as the new files will be created, and
logging will continue correctly.

Since the default cron daily job does not force the log rotation, you may want to add -f parameter to /etc/cron.daily/logrotate:

#!/bin/sh

test -x /usr/sbin/logrotate || exit 0
/usr/sbin/logrotate -f /etc/logrotate.conf

With this change, the logs will be forced to rotate daily according to the setup.

Luckily, I got a fully equipped hand-me-down Compaq (HP) ProLiant DL360 G2 server and I decided to migrate my website over during the weekend.

Even though this server is a few generations behind, it has dual Pentium III S 1.4 GHz processors, 15,000 RMP SCSI harddrive and 4GB of RAM which is more than plenty to meet my near future needs.

Since my web server was running on Ubuntu Server 8.04, this hardware upgrade also gives me an opportunity to upgrade the OS to the latest version of Ubuntu Server (10.04) which is also an LTS version.

With the new hardware and software, the site should be running rather smoothly for the next couple of years…

Since I had quite a few unofficial packages installed on my primary PC, I was not quite sure how the upgrade would turn out and I was prepared to see a few gotchas at some point. But the upgrade process was surprisingly smooth (albeit slow since all new versions of the installed packages had to be fetched first), and when the upgrade process is done I was able to boot into the new desktop. The only thing I needed to do was to re-install the CUDA driver (190.18), but this was to be expected since every major kernel updates would require the CUDA driver to be re-installed. I certainly hope that NVidia would make their proprietary binary drivers more robust by detecting kernel changes and reinstall automatically if necessary as opposed to require the end user’s manual intervention.

For my other machine running Ubuntu 9.04, the upgrade was equally smooth. One of the problems I ran into there was due to my VMWare Server installation. As it turned out, there are some issues with the default installation package that came with VMWare Server 2. The problem however can be resolved with Radu’s installation script.

To enable administrative share access from Linux hosts, we need to change the Windows machine’s security policy. My assumption is that you are using Windows XP. You may need to make further changes depending on the version of Windows you are using.

The security policy snap-in is located at

c:\windows\system32\secpol.msc

Select local policies and then Security Options:

Then select sharing and security model for local accounts:

Under the enhanced security scheme, “Guest only: local users authenticate as guests” is chosen. This policy means that administrative network access is treated as if it was done with a guest account and therefore you would get permission denied error when trying to access an administrative share — even though your account has administrative rights locally.

To allow administrative share on Samba network, you can simply select the other option “Classic: local users authenticate as themselves”.

So I followed the instructions given in these two blogs: Install Mono 2.4 on Ubuntu,
Building Mono and MonoDevelop from source on Ubuntu 9.04 64bit to re-install Monodevelop 2.0 and its dependencies from the source.

One thing you will need to pay special attention to is that for the monodevelop-debugger-mdb-2.0 to compile successfully, you will need mono-debugger version 2.4, instead of the latest version 2.4.1. Otherwise you will receive an error on Thread.AbortInvocation as there is a breaking change in mono-debugger 2.4.1 which added a parameter to the method (see mono debugger 2.4.1 change log).

For those who are impatient, the function to perform recursive directory search is here:

#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>
#include <vector>
#include <string>
#include <iostream>
#include <boost/regex.hpp>

void GetFileListing(vector<string> &files, string dir, string filter, bool ignoreCase) {
    DIR *d;
    if ((d = opendir(dir.c_str())) == NULL) return;
    if (dir.at(dir.length() - 1) != '/') dir += "/";

    struct dirent *dent;
    struct stat st;
    boost::regex exp;

    if (ignoreCase)
        exp.set_expression(filter, boost::regex_constants::icase);
    else
        exp.set_expression(filter);

    while ((dent = readdir(d)) != NULL) {
        string path = dir;

        if (string(dent->d_name) != "." && string(dent->d_name) != "..") {
            path += string(dent->d_name);
            const char *p = path.c_str();
            lstat(p, &st);

            if (S_ISDIR(st.st_mode)) {
                GetFiles(files, (path + string("/")).c_str(), filter, ignoreCase);
            } else {
                if (filter == ".*") {
                    files.push_back(path);
                } else {
                    if (boost::regex_match(string(dent->d_name), exp)) files.push_back(path);
                }
            }
        }
    }

    closedir(d);
}

I used boost library to perform regular expression matches for file names. If you just want to obtain a listing of all the files, you can do without using the boost library.

The following code snippet demonstrates how to use the function. The results are stored in a vector container passed in. Note that the “filter” parameter needs standard regular expressions (so if you are looking for any files, the expression should be .* instead of just *) to work properly.

The code should be pretty self-explanatory. If ignoreCase is set to true, then the match will be case-insensitive.

vector<string> files;

FileUtils::GetFiles(files,"/tmp", ".*", true);
for (int i = 0 ; i < files.size(); i++) {
    cout << files[i] << endl;
}

I have a lot of important programs on my main PC and I wanted to be extra cautious, so instead of backing up the working harddrive and install Ubuntu 9.04 on top of it, I decided to install it on a new harddrive. This way, I could always fall back to my currently working Ubuntu 8.04 installation should something not working out the way I wanted.

The drive I chose to install Ubuntu 9.04 on was a Western Digital Caviar Black WD1001FALS (1TB). The installation went smoothly and ten minutes later I was able to use the brand new Ubuntu 9.04 desktop.

It took me a while to customize the desktop, install the applications I needed and migrate the data over. But everything pretty much worked out-of-box. And it certainly feels a lot faster than Ubuntu 8.04.

The only minor “glitch” I ran into was my dual sound card setup. As I mentioned in an earlier post, I needed to use a second sound card because my on board Intel sound board does not have a MIDI/Game port. I needed that port to hook up my old MIDI keyboard. After the installation though, the sound playback would only go through the Sound Blaster sound card, not the on board Intel HDA sound card. There are various posts (1,2,3,4,5) suggesting how to fix this issue but unfortunately none of them worked in my case. No matter which sound card I initialized first, I always ended up with the Sound Blaster Live card working but not the on-board Intel sound card. Here is how I fixed it: I removed the Sound Blaster Live card first and booted up with just the on board sound. After making sure that the on board sound worked properly, I plugged in the Sound Blaster PCI card and then everything worked as desired (the sound now comes from the on-board Intel HDA instead of the Sound Blaster card).

As a side note, it seems that WD1001FALS does have some performance advantage over WD6400AAKS (which is the harddrive I run Ubuntu 8.04 on) even though their platter densities are quite comparable (333MB/platter versus 320MB/platter).

The simplest way is to use the mean value of the gray scale image pixel values. As a rule of thumb, we set the low threshold to 0.66*[mean value] and set the high threshold to 1.33*[mean value]. Another way is to use the median color in the gray scale image and uses 0.66*[median value] and 1.33*[median value] accordingly. For typical images, these two methods achieve comparable results.

For example, the following shows the picture of a building along with its histogram (original image from Microsoft Research Digital Image. Please see Microsoft Research Digital Image License Agreement for more information):

Building

Building Histogram

The following shows the edge detection results using Canny algorithm (left image uses mean value auto-thresholding, right image uses median value auto-thresholding) and the results exhibit very little visible differences.

Building (Canny Mean)

Building (Canny Median)

However, for images has non-equalized histogram (see the picture of cloud and its histogram below):

Cloud

Cloud Histogram

Canny Edge detection result based on mean value auto-thresholding is pretty poor (see image on the left below), while edge detection based on median value auto-thresholding achieved much better result (see image on the right below)

Cloud (Canny Mean)

Cloud (Canny Median)

Alternatively, we could have performed histogram equalization on the image first before applying Canny edge detection with mean auto-thresholding:

Cloud Equalized

Cloud Equalized Histogram

And after image equalization, both mean and median value auto-thresholding achieved similar results.

Cloud Equalized (Canny Mean)

Cloud Equalized (Canny Median)

So the Canny edge detection using median value auto-thresholding seems to adapt to different types of images very well (note selecting the median value selection can be thought as equalizing the histogram, except that the pixel values are not changed during such operation).

The following is the code listing for the histogram calculation using IPP (based on the image class I created earlier)

/** @brief Get the min max mean value statistics for the current image
 *   @param min, max, mean: these are output parameters that are passed
 *         back by reference.
 */
void IPPGrayImage::MinMaxMean(float& min, float& max, double& mean)
{
    IppStatus sts;
    IppiSize origImgSize = {_width, _height};

    sts = ippiMinMax_32f_C1R(_imgBuffer, _width * PIXEL_SIZE, origImgSize, &min, &max);
    assert(sts == ippStsNoErr);
    sts = ippiMean_32f_C1R(_imgBuffer, _width * PIXEL_SIZE, origImgSize, &mean, ippAlgHintFast);
    assert(sts == ippStsNoErr);
}

/** @brief Calculate the histogram of the image
 *   @param nLevel: the number of bins in the histogram
 *        levels: this is the optional levels user can pass in (histogram will be then
 *                calculated with these levels instead of the uniform levels by default.
 *   @return an integer array which contains the histogram.
 *   @note the histogram is by default calculated using uniform bins across the color range.
 */
unsigned int * IPPGrayImage::GetHistogram(unsigned int nLevel, float levels[])
{
    IppStatus sts;
    Ipp32f* l = new Ipp32f[nLevel];
    IppiSize origImgSize = {_width, _height};

    unsigned int* bins = new unsigned int[nLevel - 1];

    float minVal = 0, maxVal = 0, stepVal = 0;
    double meanVal = 0;
    if (levels != NULL)
    {
        for (unsigned int i = 0; i < nLevel; i++)
        {
            l[i] = levels[i];
        }
    }
    else
    {
        MinMaxMean(minVal, maxVal, meanVal);
        stepVal = (maxVal - minVal) / (float) nLevel;

        for (unsigned int i = 0; i < nLevel; i++)
        {
            l[i] = minVal + stepVal * i;
        }
    }

    sts = ippiHistogramRange_32f_C1R(_imgBuffer, _width * PIXEL_SIZE, origImgSize, (Ipp32s*) bins, (Ipp32f*) l, nLevel);
    return bins;
}

As I mentioned a few days ago, I installed Ubuntu 9.04 on one of my home machines the day it became available and while no radical new features introduced I liked the improvements over 8.10 and 8.04. Since haven’t tried KDE for a while, I decide to download and install the latest Kubuntu 9.04 on VMWare and give it a try.

Kubuntu’s installation process is as easy as it could be just like installing Ubuntu. It took only a minute or two longer than installing Ubuntu but within 10 minutes I was ready to log in.

What I liked
The new Dolphin file manager is extremely fast and easy to use. I like the the places side bar where you could create shortcuts to your favorite folders. The performance of Dolphin is also much faster than Nautilus in Gnome. For smaller folder sizes (e.g. folders with less than 100 files) there is usually very little noticeable performance issue in either file managers. But with large folders (e.g. folders with a few thousands files), Nautilus becomes unbearably slow. Dolphin seems to have little trouble handling large folders.

I also like the “filter” capability in Dolphin. It makes finding files in folders much easier.

The new KDE application launcher is also very pleasant to use and I think it is certainly a big improvement over KDE 3′s start menu. The main menu usability has almost been my main issue when using GNOME. Even though alternative menus such as Gnome Main Menu and Ubuntu System Panel provide similar functionalities, they lack the polish and stability of KDE’s application launcher.

The overall performance of KDE 4 seems to be on par if not better than that of KDE 3.

What I didn’t like
One of the main reasons the KDE community developed the Plasma desktop was to provide users a richer visual experience. Unfortunately I have never been a big fan of any UI visual sugars. Of course, this is totally a personal preference and opinion seems to be evenly divided within the Linux community–people either loves the new look and feel or think it is too cumbersome. And the borders of default windows are excessively thick which I think it is a waste of screen real estate.

The new task bar is a bit buggy and seems to be too easy to mess up, it would help to have a menu item called “restore to default layout”.

One of the problem I ran into was that Kubuntu somehow couldn’t remember the screen resolution setting under VMWare (by the way, I was using the 64bit version of Kubuntu). And every time after a reboot the screen size got automatically reset to 640×480. I am not sure whether this particular issue is related to just VMWare (6.5.2), but it was very annoying as I had to manually adjust the screen resolution every time. And once the screen resolution is adjusted, font sizes on certain applications got messed up. It seems that the font in Konqueror got scaled up multiple times somehow and looks ridiculously large.

So I guess I will have to stick to my GNOME desktop for a long while…

This kind of enthusiasm is certainly encouraging as Linux matures. And certainly, this kind of enthusiasm is much needed for the open source community in general. Whether it is proprietary software or free software, the community acceptance is definitely key to the success of its future.

I have three systems running on Ubuntu at home right now. My WordPress server is running Ubuntu 8.04 server (32 bit). One of my working machine is running Ubuntu 8.04 64 bit and the other is running Ubuntu 8.10. For my server, I will stick to the 8.04 as it is an LTS release. But I am thinking of installing the latest Ubuntu desktops onto my workstations in the next couple of weeks…

Update 1 8:00 PM
I have just installed Ubuntu 9.04 using the ISO image I downloaded earlier onto a VM. The installation was made even easier (the time zone is now selected by default). The default installation took just about five minutes. The boot time is also very impressive. It took just about 20 seconds before showing the login screen, which is a big improvement over my 8.04 installation.

Update 2 9:00 PM
Even though a fresh installation might be ideal, I decided to run the update on my Ubuntu 8.10 machine anyway. This is mainly because it was used as a file and VM server and I had done very little customizations on it besides that. So I think the chances of getting a successful upgrade is pretty high. The distribution upgrade is pretty slow though, and it is downloading at about 30k/s right now…

Upgrading from Ubuntu 8.10 to 9.04

Update 3 4/24/2009 7:00 AM
The 8.10 to 9.04 upgrade went surprisingly well. The only problem I had has nothing to do with Ubuntu.

Since the machine I was doing the update on is a file and VMs server, I did not bother attach display or keyboard to it. So when I was doing the update yesterday used an SSH connection and forgot that the updates would need to shutdown SSH and other services in order to install the newer version of the daemons. Anyway, half way through the upgrade, the connection to my server was lost. At first I thought that I could just attach a monitor and keyboard to my server and continue the whole upgrade process. Of course it wouldn’t work since the upgrade process was tied to that particular terminal.

So I had to reboot the machine. For whatever reason, maybe because the machine was only half upgraded, the normal boot does not work and I could not log in via the graphical login screen. I restarted in “safe” mode dropping into a root shell and did a

sudo dpkg –configure -a

And the upgrade process picked up from where it was left at before. This is truly impressive! After the upgrade process finished, I rebooted into the new 9.04 installation:

sudo lsb_release -a

Distributor ID: Ubuntu
Description: Ubuntu 9.04
Release: 9.04
Codename: jaunty

The only thing that did not work after the upgrade was the VMWare Server (which is totally expected as it needs to link to the correct version of libraries). But after a simple re-config, the VMWare Server came back into life.

In my opinion, the above three IDEs all have their strengths and weaknesses depending on what kind of project you are working on. Here are some of my observations.

KDevelop is probably the most comprehensive IDE of the three. This should not come as a surprise as it has been around for more than 10 years and it bas been the de facto development environment for most of the KDE development work. It is very feature rich and you can use it to develop many different types of applications natively out of box (e.g. KDE, GTK+, Qt, wxWidgets, etc). If you are developing GNU style applications, you will benefit from the Automake project type if provides. Besides the vast functionalities KDevelop provides, it is also very fast, efficient and stable.

Nonetheless, KDevelop is not the most intuitive IDE and does not suit small projects (e.g. prof of concept code) well as the initial project setup can be time consuming.

Code::Blocks is a very capable IDE for C++ development as well. It offers many project templates even though it does not offer native KDE project types. This should not be a problem to most people however. Among the features I like the most is that it does not require explicit make file configuration and the build dependencies are inferred by default. This makes it very attractive for rapid prototyping. Debugging under Code::Blocks is also a pleasant experience. It also integrates (at least in the later SVN versions) Valgrind‘s MemCheck and Cachegrind, which are very useful for detecting memory leaks and tweaking algorithms for the maximum performance.

The latest stable version of Code::Blocks is 8.02, it is a little dated as a lot of functionalities have been added in the later SVN builds. If you do not require the most stability (I have run into some issues recently), using SVN build should not be a problem. The editor (e.g. syntax highlighting, collapsible regions) is a little bit buggy though and the contextual help does not always work to the level of detail I desired.

NetBeans C++ IDE is probably the most beautiful one among the three. It offers the most detailed syntax highlighting, and can be configured to display class hierarchy and library function information. The refactor tool works pretty well and is certainly a boon to large scale development. Its contextual help is also of top-notch.

All of these come at a cost of course. NetBeans C++ IDE is the most resource intensive among the three. It can easily use 500 MB memory when doing development and can be sluggish at times. It also comes with a very limited project template (e.g. no out-of-box project templates for Qt, wxWidgets). Certain settings are hard to get at as well. Nevertheless, if I am primarily writing back-end code, NetBeans C++ IDE could easily earn my top choice.

Some people like Anjuta and compare it favorably to Code::Blocks. But I haven’t got a chance to use it yet.

So naturally, I wanted to revert back to my previous working version (SVN 5489). There are some instructions on lgp203.free.fr that in theory should work to install any revisions of Code::Blocks from SVN. But the script provided there did not work for me as it was complaining about not able to find certain packages. So I decided to do it manually, and here are the steps I took to get SVN 5489 installed.

First, you will need to remove the installed version of Code::Blocks.

sudo apt-get remove codeblocks
sudo apt-get remove codeblocks-common

Then you will need to install the Debian packages one by one from lgp203.free.fr. using

wget http://lgp203.free.fr/pool/codeblocks/wxsmith-headers_8.02svn5489_all.deb
wget http://lgp203.free.fr/pool/codeblocks/libwxsmithlib0_8.02svn5489_amd64.deb
wget http://lgp203.free.fr/pool/codeblocks/codeblocks-headers_8.02svn5489_all.deb
wget http://lgp203.free.fr/pool/codeblocks/libcodeblocks0_8.02svn5489_amd64.deb
wget http://lgp203.free.fr/pool/codeblocks/codeblocks_8.02svn5489_amd64.deb
wget http://lgp203.free.fr/pool/codeblocks/codeblocks-common_8.02svn5489_all.deb
wget http://lgp203.free.fr/pool/codeblocks/codeblocks-contrib_8.02svn5489_amd64.deb
wget http://lgp203.free.fr/pool/codeblocks/codeblocks-contrib-common_8.02svn5489_all.deb

sudo dpkg -i wxsmith-headers_8.02svn5489_all.deb
sudo dpkg -i libwxsmithlib0_8.02svn5489_amd64.deb
sudo dpkg -i codeblocks-headers_8.02svn5489_all.deb
sudo dpkg -i libcodeblocks0_8.02svn5489_amd64.deb
sudo dpkg -i codeblocks_8.02svn5489_amd64.deb
sudo dpkg -i codeblocks-common_8.02svn5489_all.deb
sudo dpkg -i codeblocks-contrib_8.02svn5489_amd64.deb
sudo dpkg -i codeblocks-contrib-common_8.02svn5489_all.deb

You can find a full list of all the available Code::Blocks’ SVN versions here. Now, I am running version 5489 and everything is working again.

What I have found out over time is that the default IO priorities tend to cause the UI very sluggish when doing heavy IO operations (e.g. copying files between disks, etc.). While this problem is not inherent to Linux (Linux is only the kernel), The default sluggish behavior under heavy IO conditions makes popular Linux distributions (e.g. Ubuntu) less user friendly than it should.

While using ionice can solve this issue, it isn’t very continent as it needs to be manually set every time the user performs heavy IO tasks.

It is true that the performance of the main-stream hard drives/and controllers (e.g. SATA) is partially responsible for the sluggishness of the UI response and higher end disk sub-systems like serial attached SCSI alleviate this problem to a certain degree, for Linux to really go main stream nevertheless, this problem should not be overlooked as SATA is the common disk sub-system almost all main-stream users have.

Since copying large files is such a common task nowadays, why couldn’t we just lower the default IO priority settings instead of relying on user to use ionice? In general, most end users care more about the UI responsiveness than the background disk throughput.

In this article, I will show a simple example of creating a wrapper class using IPP and Magick++. The example I am going to show can be used to calculate the 2-dimensional FFT spectrum of a gray-scale image. This framework can be easily extended to include other algorithms that can be applied to an image using IPP.

Before I show the implementation details, let me first show how easy it is to use the class. The code snippet below shows how to read in an image file, apply 2D FFT with and without a Hamming window and save the results into image files.

    IPPGrayImage *img, *img1;

    img = new IPPGrayImage();
    img->LoadFromFile(IMAGE_FILE);

    img1 = img->Clone();
    img1 = img1->FFT(true);
    img1->SaveToFile(IMAGE_HOME + "/test_fftmag.jpg");
    img1 = img->Clone();
    img1 = img->ApplyHammingWindow();
    img1->SaveToFile(IMAGE_HOME + "/test_hamming.jpg");
    img1 = img1->FFT(true);
    img1->SaveToFile(IMAGE_HOME + "/test_fftmag_hamming.jpg");

And for the following IMAGE_FILE,

Test image used for 2D FFT

Here are the results for FFT spectrum with and without hamming window:

Hamming window applied

FFT spectrum (without Hamming window)

FFT spectrum with Hamming window

The header file for the class is as follows:

#ifndef IPPGRAYIMAGE_H
#define IPPGRAYIMAGE_H

#include <Magick++/Image.h>
#include <Magick++.h>
#include <ipp.h>

using namespace std;
using namespace Magick;

namespace KDW
{
    class IPPGrayImage
    {
    public:
        unsigned int PIXEL_SIZE;

        IPPGrayImage();
        IPPGrayImage(const unsigned int width, const unsigned int height);
        IPPGrayImage(Ipp32f *imgBuffer, const unsigned int width, const unsigned int height);
        IPPGrayImage(const IPPGrayImage& other);
        virtual ~IPPGrayImage();
        IPPGrayImage& operator=(const IPPGrayImage& other);

        void LoadFromFile(string fileName);
        void SaveToFile();
        void SaveToFile(string fileName);

        inline float GetPixel(unsigned int col, unsigned int row) {return _imgBuffer[row * _width + col];}
        inline void SetPixel(unsigned int col, unsigned int row, float clr) {_imgBuffer[row * _width + col] = clr;}

        unsigned int GetWidth() { return _width;}
        unsigned int GetHeight() { return _height;}

        Ipp32f* GetImageBuffer() { return _imgBuffer;}
        Image* GetImage() { return _img;}

        IPPGrayImage* Clone();
        IPPGrayImage* ApplyHammingWindow();
        IPPGrayImage* FFT(bool fftShift = false);
    protected:
    private:
        unsigned int _width;
        unsigned int _height;

        Image* _img;
        Pixels* _view;
        PixelPacket* _pixels;
        Ipp32f* _imgBuffer;
        string _fileName;

        void Init();
    };
}
#endif // IPPGRAYIMAGE_H

And here’s the implementation for the class:

#include <assert.h>
#include <math.h>

#include "IPPGrayImage.h"

namespace KDW
{
    /** @brief Constructor()
     *  Initialize image buffer.
     */
    IPPGrayImage::IPPGrayImage()
    {
        Init();
    }

    /** @brief Constructor(width, height)
     *  Initialize an image size of width x height.
     */
    IPPGrayImage::IPPGrayImage(const unsigned int width, const unsigned int height)
    {
        Init();

        _width = width;
        _height = height;

        int stepByte = 0;
        _imgBuffer = ippiMalloc_32f_C1(_width, _height, &stepByte);
    }

    /** @brief Constructor(imgBuffer, width, height)
     *  Initilize from an Ipp32f buffer (width x height)
     */
    IPPGrayImage::IPPGrayImage(Ipp32f *imgBuffer, const unsigned int width, const unsigned int height)
    {
        Init();

        _width = width;
        _height = height;
        _imgBuffer = imgBuffer;
    }

    /** @brief Copy Constructor
     */
    IPPGrayImage::IPPGrayImage(const IPPGrayImage& other)
    {
        _width = other._width;
        _height = other._height;

        int stepByte = 0;

        _imgBuffer = ippiMalloc_32f_C1(_width, _height, &stepByte);

        for (unsigned int row = 0; row < _height ; row++)
        {
            for (unsigned int column = 0; column < _width ; column++)
            {
                _imgBuffer[column + row * _width] =other._imgBuffer[column + row * _width];
            }
        }

        if (other._pixels == NULL) _pixels = NULL;
    }

    /** @brief Overload =
     */
    IPPGrayImage& IPPGrayImage::operator=(const IPPGrayImage& rhs)
    {
        if (this == &rhs) return *this; // handle self assignment

        return *this;
    }

    /**
     * @brief Destructor
     */
    IPPGrayImage::~IPPGrayImage()
    {
        ippFree(_imgBuffer);
        delete _img;
        delete _view;
    }

    /**
     * @brief Common initialization code
     */
    void IPPGrayImage::Init()
    {
        PIXEL_SIZE = sizeof(Ipp32f);
        _pixels = NULL;
        _imgBuffer = NULL;
        _img = NULL;
    }

    /** @brief Load an image from file
      */
    void IPPGrayImage::LoadFromFile(string fileName)
    {
        _img = new Image(fileName);
        Geometry g = _img->size();

        _width = g.width();
        _height= g.height();

        _view = new Pixels(*_img);
        _pixels = _view->get(0,0, _width, _height);

        int stepByte = 0;
        _imgBuffer = ippiMalloc_32f_C1(_width, _height, &stepByte);

        for (unsigned int row = 0; row < _height ; row++)
        {
            for (unsigned int column = 0; column < _width ; column++)
            {
                PixelPacket *p = &_pixels[column + row * _width];
                Color c = Color(p->red, p->green, p->blue);
                _imgBuffer[column + row * _width] = c.intensity();
            }
        }
    }

    /** @brief Save the current image buffer to file
      */
    void IPPGrayImage::SaveToFile()
    {
        SaveToFile("");
    }

    /** @brief SaveToFile(fileName)
     *  Saves the current image buffer to a file (by file name).
     */
    void IPPGrayImage::SaveToFile(string fileName)
    {
        if (_img != NULL && _pixels != NULL)
        {
            for (unsigned int y = 0; y< _height ; y++)
            {
                for (unsigned int x = 0; x < _width; x++)
                {
                    float clr = (float) _imgBuffer[x + y * _width];
                    _pixels[x+ y * _width] = Color(clr, clr, clr);
                }
            }
            _view->sync();
            _img->syncPixels();

            if (fileName == "")
            {
                _img->write(_fileName);
            }
            else
            {
                _img->write(fileName);
            }
        }
        else
        {
            Image img(Geometry(_width, _height),"white");

            for (unsigned int y = 0; y< _height ; y++)
            {
                for (unsigned int x = 0; x < _width; x++)
                {
                    Color c;
                    float clr = (float) _imgBuffer[x + y * _width];
                    img.pixelColor(x,y, Color(clr, clr, clr));
                }
            }

            img.write(fileName);
        }
    }

    /** @brief Clone
    *   Duplicate the current image to another IPPGrayImage object.
    *   @return an IPPGrayImage pointer to the cloned image
    */
    IPPGrayImage* IPPGrayImage::Clone()
    {
        IPPGrayImage *newImg;

        newImg = new IPPGrayImage(_width, _height);

        int stepByte = 0;
        newImg->_imgBuffer = ippiMalloc_32f_C1(_width,_height, &stepByte);

        for (unsigned int y = 0 ; y < _height ; y++)
        {
            for (unsigned int x = 0 ; x < _width ; x++)
            {
                newImg->_imgBuffer[x + y * _width] = _imgBuffer[x + y * _width];
            }
        }

        return newImg;
    }

    /** @brief Apply Hamming window to the image
     *  @return an IPPGrayImage pointer to the processed image
     */
    IPPGrayImage* IPPGrayImage::ApplyHammingWindow()
    {
        IPPGrayImage *newImg;
        newImg = new IPPGrayImage(_width , _height);
        IppiSize srcImgSize = {_width, _height};

        IppStatus sts;
        int stepByte;
        Ipp32f *imgCache = ippiMalloc_32f_C1(_width , _height , &stepByte);

        sts = ippiWinHamming_32f_C1R(_imgBuffer, _width * PIXEL_SIZE, imgCache, _width * PIXEL_SIZE, srcImgSize);
        assert(sts ==ippStsNoErr);

        for (unsigned int y = 0; y< _height; y++)
        {
            for (unsigned int x = 0; x < _width; x++)
            {
                newImg->_imgBuffer[x+ y * _width] = imgCache[x + y * _width];
            }
        }

        return newImg;
    }

    /** @brief Perform FFT on the image and returns the magnitude component
     *  @param fftShift: if it is true, the the result is with
     *         zero-frequency component shifted to center of spectrum
     *  @return the magnitude FFT component
     */
    IPPGrayImage* IPPGrayImage::FFT(bool fftShift)
    {
        IPPGrayImage *newImg;
        IppiFFTSpec_R_32f *spec;
        IppStatus sts;

        unsigned int n = (int) (logf((float) _width) / logf(2.0f));
        unsigned int m = (int) (logf((float) _height) / logf(2.0f));

        unsigned int N = pow(2, n);
        unsigned int M = pow(2, m);

        if (N < _width)
        {
            n = n + 1;
            N = pow(2, n);
        }

        if (M < _height)
        {
            m = m + 1;
            M = pow(2, m);
        }

        int stepByte;
        Ipp32f *src = ippiMalloc_32f_C1(M , N , &stepByte);
        Ipp32f *dst = ippiMalloc_32f_C1(M , N , &stepByte);
        Ipp32f *mag = ippiMalloc_32f_C1(M , N , &stepByte);

        IppiSize srcImgSize = {_width, _height};
        IppiSize dstImgSize = {N, M};

        sts = ippiCopyConstBorder_32f_C1R(
                  _imgBuffer, _width * PIXEL_SIZE, srcImgSize,
                  src,  N * PIXEL_SIZE, dstImgSize,
                  0,0,0);
        assert(sts ==ippStsNoErr);

        sts = ippiFFTInitAlloc_R_32f(&spec, n , m, IPP_FFT_DIV_BY_SQRTN, ippAlgHintAccurate);
        assert(sts ==ippStsNoErr);

        sts = ippiFFTFwd_RToPack_32f_C1R(src, N*PIXEL_SIZE, dst, N*PIXEL_SIZE, spec, 0);
        assert(sts ==ippStsNoErr);

        sts = ippiMagnitudePack_32f_C1R(dst, N*PIXEL_SIZE, mag, N*PIXEL_SIZE, dstImgSize);
        assert (sts ==ippStsNoErr);

        newImg = new IPPGrayImage(N , M);

        if (fftShift)
        {
#pragma omp sections
            {
#pragma omp section
                {
                    for (unsigned int y = 0 ; y < M/2; y++)
                    {
                        for (unsigned int x = 0 ; x < N/2; x++)
                        {
                            newImg->_imgBuffer[x+ y *N] = mag[x + N/2 + (y + M/2) * N];
                        }
                    }
                }
#pragma omp section
                {
                    for (unsigned int y = 0 ; y < M/2; y++)
                    {
                        for (unsigned int x = N/2 ; x < N; x++)
                        {
                            newImg->_imgBuffer[x+ y *N] = mag[x - N/2 + (y + M/2) * N];
                        }
                    }
                }
#pragma omp section
                {
                    for (unsigned int y = M/2 ; y < M; y++)
                    {
                        for (unsigned int x = 0 ; x < N/2; x++)
                        {
                            newImg->_imgBuffer[x+ y *N] = mag[x + N/2 + (y - M/2) * N];
                        }
                    }
                }
#pragma omp section
                {
                    for (unsigned int y = M/2 ; y < M; y++)
                    {
                        for (unsigned int x = N/2 ; x < N; x++)
                        {
                            newImg->_imgBuffer[x+ y *N] = mag[x - N/2 + (y - M/2) * N];
                        }
                    }
                }
            }
        }
        else
        {
            for (unsigned int y = 0; y< M; y++)
            {
                for (unsigned int x = 0; x <N; x++)
                {
                    newImg->_imgBuffer[x+ y * N] = mag[x + y * N];
                }
            }

        }

        return newImg;
    }
}

The above example showed only the FFT function, but virtually all IPP image routines can be accommodated using the wrapper image class above. Intel IPP utilizes many different data types (e.g. Ipp8u, Ipp16s, Ipp32f etc.), but to provide most of the flexibility and compatibility I chose to use only the 32 bit floating data type. For specific implementations, other data types can be used as well.

While personally I see Linux and other UNIX variants as strong candidates to have the possibility to eventually replace Windows in both the consumer domain and the enterprise domain, it seems that this sea change is not going to happen any time soon as predicted by some.

Today although Linux is widely used in the server market, in the consumer domain it remains a niche market, accounting for just around 2% of market shares. Even thought the current economic down turn had sped up Linux’s adoption, it is still too small to make any significant impact on the overall consumer OS landscape.

Don’t get me wrong, I think that Linux is an excellent operating systems and in fact I think that it is a perfect Windows replacement for all the technical folks and certainly geeks. But the following issues remain some of the big obstacles for the normal consumers.

Codec

This is not the problem of Linux per se. Due to the open source nature and the various legal reasons, most free Linux distributions (e.g. Ubuntu, openSUSE) do not come with popular codecs (e.g. the codecs for playing back MP3′s and WMV files) installed. While for geeks it might be quite trivial to dig around in the vast Linux application repositories and find the exact codecs needed in a matter of minutes, the average Joes might have a hard time figuring out why his favorite DVD won’t play on his Linux system.

Consumer Applications

This gap has been closing rapidly over the years. Now we have FireFox, Thunderbird, OpenOffice and many other productivity applications come as standard in almost all popular distros. And even some professional software suites have their alternatives in the Linux World. For example, GIMP is a capable replacement for Adobe Photoshop. However, many of the most popular consumer software products remains missing on the Linux platform. Computer game is one of them. While I do not play computer games, many people would like to use their PCs to play some popular games occasionally. And to some, because of these Windows only and no Linux equivalent applications, there is no alternative but to use Windows.

Drag and Drop

For those who are used to Windows, drag and drop seems to be a given. All most all applications in Windows support drag and drop, but on Linux such support is inconsistent at best.

Copy and Paste

This is another area frustrates a lot of Windows users. In Windows, copy and paste pretty much works among all the applications. In Linux however, it does not always work and sometimes

The Command Line

Most Linux distributions use BASH. For seasoned users, using the command line is just as convenient if not more so than using a GUI equivalent application. In fact I personally prefer the “terminal” as it gave me the most flexibility and none of the overhead. But we can not expect every user has the same level of comfort with the command line environment.

I just mentioned a few areas where I think are among some of the main obstacles to the broad adoption of Linux. And most of these are interoperability issues which are not going to be resolved anytime soon. To the advanced users, most of these issues are pretty minor and there are many ways to work around. But to the average users who have accustomed to the consistencies within the system, even minor incontinence can mean a show stopper.

With all that said, I have found Linux to be a very attractive platform. While Linux might not be able to replace the proprietary Windows anytime soon for the reasons I discussed above, it has seeded deeply inside many people who believe in the free software movement and I am hopeful that one day we will see the OS world dominated by open source software, be it Linux or something else.

Even though a lot of optimizations have been done in the .Net runtime to make it more efficient, it is apparent that scientific programming still favors C and C++ because that the performance advantage is huge.

In this article, I will examine some matrix multiplication algorithms that are commonly used and illustrate the efficiencies of the various methods. All the tests are done using C++ only and matrices size ranging from 500×500 to 2000×2000. When the matrix sizes are small (e.g. <50), you can pretty much use any matrix multiplication algorithms without observing any significant performance differences. This is largely due to the fact that the typical stable matrix multiplication algorithms are O(n^3) and sometimes array operation overheads outweigh the benefit of algorithm efficiencies. But for matrices of larger dimensions, the efficiency of the multiplication algorithm becomes extremely important.

Since Dmitri’s article has already captured pretty detailed data using the standard matrix multiplication algorithm, I will not repeat his findings in this article. What I intended to show was the performance data of uBLAS, OpenMP, cBLAS and MATLAB.

The following sample code are compiled under Ubuntu 8.10 64 bit (kernel 2.6.24.23) on Intel Q9450@3.2GHz.

Standard Matrix Multiplication (Single Threaded)

This is our reference code. Later on, I will only show the critical portion of the code and not repeat the common portion of code that initializes/finalizes the arrays. Similarly, the timing method used is also the same across all the tests and will be omitted later on.

float **A, **B, **C;

A = new float*[matrix_size];
B = new float*[matrix_size];
C = new float*[matrix_size];

for (int i = 0 ; i < matrix_size; i++)
{
    A[i] = new float[matrix_size];
    B[i] = new float[matrix_size];
    C[i] = new float[matrix_size];
}

for (int i=0; i<matrix_size; i++)
{
    for (int j = 0 ; j < matrix_size; j++)
    {
        A[i][j]=rand();
        B[i][j]=rand();
    }
}

timeval t1, t2, t;
gettimeofday(&t1, NULL);

for (int i = 0 ; i < matrix_size; i++)
{
    for (int j = 0;  j < matrix_size; j++)
    {
        C[i][j] = 0;
        for (int k = 0; k < matrix_size; k++)
        {
            C[i][j] += A[i][k] * B[k][j];
        }
    }
}

gettimeofday(&t2, NULL);
timersub(&t2, &t1, &t);

cout << t.tv_sec + t.tv_usec/1000000.0 << " Seconds -- Standard" << endl;

for (int i = 0 ; i < matrix_size; i++)
{
    delete A[i];
    delete B[i];
    delete C[i];
}

delete A;
delete B;
delete C;

OpenMP With Two Dimensional Arrays

Using OpenMP, we are able to multiple threads via the #pragma omp directives. For the simple algorithm we used here, the speed increase is almost proportional to the number of available cores within the system.

...
#pragma omp parallel for shared(a,b,c)
for (long i=0; i<matrix_size; i++)
{
    for (long j = 0; j < matrix_size; j++)
    {
        float sum = 0;
        for (long k = 0; k < matrix_size; k++)
        {
            sum +=a[i][k]*b[k][j];
        }
        c[i][j] = sum;
    }
}
...

OpenMP With One Dimensional Arrays

Cache locality is poor using the simple algorithm I showed above. The performance can be easily improved however by improving the locality of the references. One way to achieve better cache locality is to use one dimensional array instead of two dimensional array and as you will see later, the performance of the following implementation has as much as 50% speed gains over the previous OpenMP implementation using two dimensional arrays.

float *a, *b, *c;

a = new float[matrix_size * matrix_size];
b = new float[matrix_size * matrix_size];
c = new float[matrix_size * matrix_size];

for (long i=0; i<matrix_size * matrix_size; i++)
{
    a[i]=rand();
    b[i] = rand();
    c[i] = 0;
}

#pragma omp parallel for shared(a,b,c)
for (long i=0; i<matrix_size; i++)
{
    for (long j = 0; j < matrix_size; j++)
    {
        long idx = i * matrix_size;
        float sum = 0;
        for (long k = 0; k < matrix_size; k++)
        {
            sum +=a[idx + k]*b[k * matrix_size +j];
        }
        c[idx + j] = sum;
    }
}

delete a;
delete b;
delete c;

Boost Library uBLAS (Single Threaded)

Boost library provides a convenient way to perform matrix multiplication. However, the performance is very poor compared to all other approaches mentioned in this article. The performance of the uBLAS implementation is largely on par with that using C# (see benchmarks towards the end of the article). Intel’s Math Kernal Library (MKL) 10.1 does provide functionality to dynamically convert code using uBLAS syntax into highly efficient code using MKL by the inclusion of header file mkl_boost_ublas_matrix_prod.hpp. I have not tried it myself though, but the performance should be comparible to algorithms using the native MKL BLAS interface.

By default (without using MKL’s uBLAS capability) though, uBLAS is single threaded and due to its poor performance and I would strongly suggest avoid using uBLAS in any high performance scientific applications.

matrix<float> A, B, C;

A.resize(matrix_size,matrix_size);
B.resize(matrix_size,matrix_size);

for (int i = 0; i < matrix_size; ++ i)
{
    for (int j = 0; j < matrix_size; ++ j)
    {
        A(i, j) = rand();
        B(i, j) = rand();
    }
}

C =prod(A, B);

Intel Math Kernel Library (MKL) cBLAS

Intel’s Math Kernel Library (MKL) is highly optimized on Intel’s microprocessor platforms. Given that Intel developed this library for its own processor platforms we can expect significant performance gains. I am still surprised at how fast the code runs using cBLAS though. In fact, it was so fast that I doubted the validity of the result at first. But after checking the results against those obtained by other means, those doubts were putting into rest.

The cBLAS matrix multiplication uses blocked matrix multiplication method which further improves cache locality. And it is more than thirty times faster then the fastest OMP 1D algorithm listed above! Another benefit is that by default it automatically detects the number of CPUs/cores available and uses all available threads. This behavior greatly simplifies the code since threading is handled transparently within the library.

float *A, *B, *C;

A = new float[matrix_size * matrix_size];
B = new float[matrix_size * matrix_size];
C = new float[matrix_size * matrix_size];

for (int i = 0; i < matrix_size * matrix_size; i++)
{
    A[i] = rand();
    B[i] = rand();
    C[i] = 0;
}

cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,
    matrix_size,  matrix_size,  matrix_size, 1.0, A,matrix_size,
    B, matrix_size, 0.0, C, matrix_size);

MATLAB (Single Threaded)

MATLAB is known for its efficient algorithms. In fact it uses BLAS libraries for its own matrix calculation routines. The version of MATLAB I have is a little dated (7.0.1), but nevertheless it would be interesting to see how its performance compares with that of latest MKL’s. MATLAB 7 is single threaded, and given the same matrix size, it runs roughly three times slower than the fastest MKL routine listed above (per core).

    a = rand(i,i);
    b = rand(i,i);
    tic;
    c = a*b;
    t = toc

The following table shows the results I obtained by running the code listed above. The results are time in seconds. (note, S.TH means single threaded and M.TH means multi-threaded).

The following figure shows the results. Since uBLAS and single threaded matrix multiplications took significantly longer to compute, I did not include them in the figure below.

The following figure shows the same data but uses log-scale Y axis instead so that all the data can show up nicely. You can get a sense of various algorithms’ efficiencies here:

1. Ubuntu Server Setup

The following screen shots are taken while installing Ubuntu Server 8.04 (note the latest Ubuntu Server Edition is 8.04.2)

While the default choice is Yes (Detect keyboard layout), I have found that that for the keyboards used here in the US, skipping the auto-detection step is actually easier.

This is the host name you want to use. For whatever reason, the default Ubuntu Server setting does not set the host-name correctly using DHCP (for instance, you can not use vm-wordpress to locate the server from a Windows machine). This can be addressed easily by ensuring that the following lines are present in /etc/dhcp3/dhclient.conf:

send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers, domain-name, domain-name-servers, host-name, ntp-servers;

For a dedicated server, the default partitioning scheme (use entire disk) should be suffice.

If you are setting it up on your home computer, this is usually blank.

For the WordPress server setup LAMP and OpenSSH are the only required components. However, I usually add the Print Server (CUPS) so that the whole home network can share the printer on the WordPress server (since it is always on) and Samba File Server so that I can copy files from a Windows machine.

Don’t confuse MySQL root user password with the Ubuntu login password. They can be the same but it is recommended that you use a different strong password for each.

We are almost done!

If everything goes well, you should be greeted with this login screen after your machine is re-booted.

As a best practice, you should always ensure that your distribution is up-to-date by getting the latest patches/software:

This can be achieved by issuing the following commands upon log in:

A reboot maybe necessary if kernel image is updated.

2. Create Samba Share

We have already installed Samba during the Ubuntu Server install. To use it we need to first configure it properly.

sudo vi /etc/samba/smb.conf

at the end add the following section:

Now we can add a user for Samba share:

3. Install WordPress

In your user directory (e.g. /home/{user name}):

4. Configure Database

mysql> create database wordpress;
mysql> grant all privileges on wordpress.* to "wpuser"@"localhost" identified by "password";
mysql> flush privileges;
mysql> exit

In my previous tutorial, I used phpMyAdmin as the SQL tool. While it is much easier to use then the mysql command line, it nevertheless adds some risk if you allow database logins remotely. So I would not recommand installing it on the production server.

5. Configure WordPress

Edit the content of wp-config.php:

Since our WordPress installation is located in the blog directory, the default url will be http://yourdomain/blog/. If you want your blog to be accessible from the root (e.g. http://yourdomain/) you will need to modify /var/www/blog/index.php.

First copy it to www root:

And change the require() line to point to the new path: require(‘blog/wp-blog-header.php’).

a. for new setup

Run the setup script at http://yourdomain/blog/wp-admin/install.php

After running the installation script, we want to make sure that our blog is pointed at the correct location. go to http://yourdomain/blog/wp-adming/, select options. In General Options section, you will see one line like "WordPress address (URL)" and another line like "Blog address (URL)". This is the place where you specify how your blog main url looks to the outside world. If you want your blog to appear as http://yourdomain/ then make sure WordPress address is pointed to http://yourdomain/blog and Blog address is pointed to http://yourdomain. If you want your blog to appear as http://yourdomain/blog/ then make sure both entries are the same (http://yourdomain/blog/).

Now the installation of WordPress is complete.

If you need URL rewrite capability, you will need to load the URL rewrite module:

b. for existing setup (restoring a previously backed-up database)

For a detailed discussing on how to perform backup/restore on MySQL database, please refer to this article.

If you need to access the MySQL database from another machine that is on the LAN, you will want to change /etc/mysql/my.cnf and modify the bind-address to the server address, you can read more here.

I omitted some content which are less commonly used in this article. You can refer to my previous tutorial for more information.

But for my Web server running WordPress,this backup method seemed to be an overkill. I use the following method to setup a standby WordPress server (can be either a VM or a physical machine). The backup server is always running and it’s content is synced up with the production server. In the event of a production server failure, all I need to do is to re-route the port 80 traffic to the standby server, which can be achieved in a matter of seconds.

To setup the standby server, I first installed Ubuntu server 8.04.1 (the same version as on my production server, with LAMP), and copied the WordPress content over (of course, most of the configurations need to be identical to the production server as well). To sync up the database content and the custom contents (e.g. uploaded images), the following command is scheduled to run on the server on a daily basis, which essentially backs up the content database:

on the standby server, the following commands are scheduled using cron daily to pick up the changes in production environment:

The above commands essentially restore the production database snapshot onto the standby server and sync up the custom contents.

One benefit of this hot sync technique is that the standby server is always live and can be tested readily by changing the host entry in /etc/hosts to point the production url to the standby server.

        #compress
        #delaycompress

The Perl script is quite straight forward: it basically builds a hash table and use the IP address as the key:

The two lines commented out:

can be used to identify the domain name the IP is associated with. Since reverse DNS lookup is a rather slow process, it will take a long time to resolve all the IPs. I may change it to use multiple threads to speed up the DNS lookup in the further.

Even though I have up-to-date backup of my site and I restored it without too much a fuss, I was still interested in recovering the data from the failed drive.

I mounted the drive on another computer and used ddrescure to dump the primary Linux partition into a file. It seems that the partition is pretty much intact as I did not get any error while retrieving the image from the failed disk. Note that if you want to mount the dumped image, you would need to dump only the primary partition and not the whole disk (in my case it was /dev/sdd1 instead of /dev/sdd). After successfully dumped the disk image, I was able to see everything on the failed drive by mounting the image to a directory:

sudo mount -o loop ./prod.img /mnt -t ext3

Over the next couple of days I will rebuild my production box and transfer the site back from the VM.