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.

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;
}

Here I will examine a few commonly used method in measuring time intervals under Linux. All of the following timing routines are timed against the same OpenMP parallel for loop (on a quad-core CPU, the parallel for will spawn four concurrent threads).

time()

The time() function returns time with the accuracy to a second. So this function is generally useful for measuring long-running processes.

clock()

In single-core systems, clock() is often used for time measurements. The resolution of this timer is determined by CLOCKS_PER_SEC and is usually a microsecond. Since it determines the number of CPU clock cycles elapsed, it is not particularly useful in measuring time on a multi-core processor system when there are concurrent executing threads as the result of clock() function is the accumulation of CPU clocks across all active CPUs. On a quad-core system, if all cores are at full utilization then the result time is roughly four times the wall time.

gettimeofday()

Similar to the clock() function, gettimeofday() has a resolution up to one microsecond. As the function name suggests, gettimeofday() measures the wall time and thus is suitable for time measurement in multi-core, multi-cpu systems.

rdtsc

The time stamp counter is available on most modern CPUs (since Pentium). There are many implementations based on rdtsc (e.g. on Windows systems, the Win32 API call QueryPerformanceCounter). Implementation based on rdtsc is generally very accurate (with resolution up to one nanosecond) but depending on implementation, its accuracy might be susceptible to CPU clock throttling (common in mobile CPUs). In my implementation below, the rdtsc results are divided by the CPU frequency.

grep “cpu MHz” /proc/cpuinfo | cut -d’:’ -f2

This implementation assumes that CPU frequency remains constant during operations, which could lead to poor accuracy should the CPU frequency change during the measurement. For desktop CPU though, this is less of a concern however.

clock_gettime

Like rdtsc, this function has a nanosecond accuracy and is available on all POSIX compliant systems.

Intel Threading Building Block also provides a timer function tick_count::now() and the time can easily measured using the code snippet below:

    t_start = tick_count::now();
    //statements
    t_end = tick_count::now();
    cout << (t_end - t_start).seconds() * 1000 << " ms" << endl;

The following lists the code for time measuring using the methods mentioned above.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
#include <ctime>

using namespace std;

void Foo() {
#pragma omp parallel
    {
        for (long i = 0; i < 50000; i++)
            for (long j = 0; j < 50000; j++);
    }

}

unsigned long long rdtsc() {
    unsigned a, d;

    __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));

    return ((unsigned long long) a) | (((unsigned long long) d) << 32);
}

void Time() {
    time_t t1, t2;

    time(&t1);
    Foo();
    time(&t2);

    cout << "time() : " << t2 - t1 << " s" << endl;
}

void Clock() {
    clock_t c1 = clock();
    Foo();
    clock_t c2 = clock();
    cout << "clock() : " << (float) (c2 - c1) / (float) CLOCKS_PER_SEC << " s" << endl;
}

void GetTimeOfDay() {
    timeval t1, t2, t;
    gettimeofday(&t1, NULL);
    Foo();
    gettimeofday(&t2, NULL);
    timersub(&t2, &t1, &t);

    cout << "gettimeofday() : " << t.tv_sec + t.tv_usec / 1000000.0 << " s" << endl;
}

void RDTSC() {
    unsigned long long t1, t2;

    t1 = rdtsc();
    Foo();
    t2 = rdtsc();

    cout << "rdtsc() : " << 1.0 * (t2 - t1) / 3199987.0 / 1000.0 << " s" << endl;
}

void ClockGettime() {
    timespec res, t1, t2;
    clock_getres(CLOCK_REALTIME, &res);

    clock_gettime(CLOCK_REALTIME, &t1);
    Foo();
    clock_gettime(CLOCK_REALTIME, &t2);

    cout << "clock_gettime() : "
         << (t2.tv_sec - t1.tv_sec)  + (float) (t2.tv_nsec - t1.tv_nsec) / 1000000000.0
         << " s" << endl;
}

int main() {
    cout.setf(ios::fixed);
    cout.setf(ios::showpoint);
    cout.precision(5);

    Time();
    Clock();
    GetTimeOfDay();

    RDTSC();
    ClockGettime();

    return (EXIT_SUCCESS);
}

And here is the output from my quad-core computer in debug mode.

time() : 6 s
clock() : 21.85000 s
gettimeofday() : 5.67368 s
rdtsc() : 5.65957 s
clock_gettime() : 5.65894 s

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.

Since my MIDI keyboard uses the game port interface on my Sound Blaster Live! sound card, there is no need to load any firmware. After the sound card is recognized by the system, you will find a /dev/midi device (for some reason, my midi device would change between /dev/midi and /dev/midi1 once a while, but this only happens when I access the midi device using jack). Without any additional software, you should be able to do a cat /dev/midi and see some "random" characters printed on the console whenever you press a key on the MIDI keyboard. Even without touching the MIDI keyboard, you should still see characters get printed in the console at a rate of 3 to 5 characters per second. Alternatively, you could use amidi –dump and when a key is pressed some hex values should be displayed.

After confirmed that the MIDI device is working properly, we can move on to setting up the software environment. Most of the aforementioned articles are concentrated on connecting to MIDI devices using ALSA. What I have found out though is that using OSS is much easier.

Various sources have suggested that connecting MIDI devices using ALSA have very low-latency (e.g. the time between when a key is pressed and the note is played) and thus is the preferred method. But for modern computers, this kind of latencies have rarely been a problem. There might be some difference in terms of latency between using ALSA and using OSS but they are not observable in my case.

To use OSS, all you need to do is to choose the correct option in qsynth:

qsynth settings 1

qsynth settings 2

If you have multiple sound cards configured like in my case, you can select from which sound card you want the sound to be outputted (e.g. /dev/audio or /dev/audio1 etc.). The sound does not have to be produced on the same card where the MIDI device is connected. In fact, using a single sound card as the output device might be the most attractive solution since otherwise you will need to have one pair of speakers connects to each of the soundcard output. In my case, the Sound Blaster Live! card is only used for it’s game port to connect with my MIDI keyboard.

After you have successfully restarted qsynth, you should be able to hear sound when you press on the MIDI keyboard and you should see the indicator on qsynth flashing, indicating that MIDI signal was received.

qsynth

If you see activities from qsynth but there is no sound coming out then chances are that you have chosen the wrong sound card as the output device. Note that you will have to first load a Sound Font into qsynth, otherwise you will not hear any sound either. A few popular Sound Fonts can be downloaded from here.

MIDI Setup with ALSA requires a bit more work. First you need to start the jack daemon (jack -d alsa), or you could use the GUI Jack Control. Then you can start rosegarden. If you have timidity installed you you should be able to use timidity’s port (usually 128:0) as midi device port. If you are not sure, you could use pmidi -l to find out (this shows what my configuration looks like):

 Port     Client name                       Port name
 14:0     Midi Through                      Midi Through Port-0
 20:0     SBLive! Value [CT4780]            EMU10K1 MPU-401 (UART)
 21:0     Emu10k1 WaveTable                 Emu10k1 Port 0
 21:1     Emu10k1 WaveTable                 Emu10k1 Port 1
 21:2     Emu10k1 WaveTable                 Emu10k1 Port 2
 21:3     Emu10k1 WaveTable                 Emu10k1 Port 3
128:0     TiMidity                          TiMidity port 0
128:1     TiMidity                          TiMidity port 1
128:2     TiMidity                          TiMidity port 2
128:3     TiMidity                          TiMidity port 3

You can use either the Emu10k1 ports (21:x) or TiMidity ports (128:x) as output.

Since Sound Blaster Live! utlizates hardware based SoundFont, you must load appropriate SoundFont onto the board before you can hear any playback. Due to the on-board memory limitations, not all SoundFonts can be loaded onto Sound Blaster Live! Here is an 8MB version of the Creative Sound Font that you can use with Sound Blaster Live!. To load the sound font use the following command:

sfxload 8MBGMSFX.SF2 (assuming that the Sound Font is located in the current directory)

For more detailed MIDI setup using ALSA you can refer to the two articles I mentioned. What I have found is that the MIDI environment using jack is not always stable. For instance, I could instantiate the ALSA sound driver using jackd but not directly with jack GUI. And once a while jack would lock up. Another problem is that the MIDI device name seemed to change back and forth between /dev/midi and /dev/midi1 whenever I was using jack. This might be because the fact that I am using two sound cards though. Anyway, since the performance of using OSS turned out to be quite good I did not investigate the ALSA issue much further…

It seems to me that this is more of a nasty business technique  than technical limitations. The following message is what I got when trying to view games on nbcolympics site (Firefox under Linux):

 

I do not think there is any technical reasons to limit access to just Windows and Mac OS X since we all know that Flash runs on virtually all known operating systems.

Trying to watch the game on a Windows computer is not without issues either. When I used IE I got constantly reminded that installing Silver Light would give me better experience. If this is annoying, then trying watch the game with Firefox on Windows. This is the message I got:

As you can see, I was not even offered the Flash player option!

To me, trying to use one’s market dominance to bully people into using its product is simply unacceptable. While at the end of the day someone over Redmond can claim victory, we shall all realize that this is done via unfair competition and not by product superiority. 

While in the past I have always had machines running Linux (or FreeBSD) at home, my primary PC had always been a Windows PC. But when I made the switch to a true 64-bit environment, Linux made perfect sense. My old PC was running Windows XP 32 bit, in order to take advantage of the 8 GB memory installed in my new machine, I had to move to a 64 bit OS. So my choices were either to buy a copy of Windows XP 64 bit (Vista? No thanks.) or use the freely available 64 bit Linux. And the choice was quite easy to make.

So, I decided to go with the most popular distro – Ubuntu. In fact I could have easily chosen openSUSE, or even FreeBSD (which is based on BSD UNIX) since my previous experience with them were quite positive as well. At first I did have some question whether or not I would be able to do the majority of my work on Linux, without having to constantly turning to a Windows PC. As it turned out, those worries were totally unnecessary. For the past two months, I had been using Linux almost exclusively at home except for a few moments when I needed to test something in Visual Studio .Net.

For web browsing, I use Firefox 64 bit, since there’s no 64bit Flash available for 64 bit Linux yet, I installed the 32 bit version as well. The default email client GNOME supplies is Evolution, which is quite powerful. Unfortunately, it could only import my outlook mail hierarchical Inbox folder structures into a single folder. So for my mail client, I chose Mozilla’s Thunderbird instead. For word editing, OpenOffice 3.0 is an excellent choice. In fact, I personally found it quite comparable to Microsoft Office 2007, and most Office documents can be opened/edited without any issues.

Since I like many of the tools provided in KDE, I installed the KDE environment as well (the alternative would be to install Kbuntu first and install GNOME based tools later, but it really doesn’t matter, this is the beauty of the versatilities of Linux). The default simple text editing tool (gedit in GNOME/kedit in KDE) is quite powerful compare to Windows’ notepad. The syntax highlighting capability is built in. For viewing PDF documents, I use kpdf, the KDE version of the PDF/PS file viewer. If you are used to the sluggish performance of Adobe’s Acrobat Reader, you’ll be surprised to find how snappy kpdf is.

I use K3b (KDE’s CD/DVD creator) to burn CD and DVD discs. K3b’s features rival most of the commercial CD/DVD authoring programs in the Windows world. In terms of media playback, Ubuntu handles almost all media formats out-of-box, even proprietary formats like wmv can be easily accommodated with a single mouse click. And for photo editing, I use GIMP, which is rather easy to use and almost as powerful as Photoshop.

For software development, I use Code::Blocks and KDevelop for C++ applications, MonoDevelop for C# programs. Occasionally I needed to research some work related programming issues. Since some of these issues are Windows specific, I would fire up an instance of Windows XP (or Windows Vista) within VMWare Server and use Visual Studio from there.

There hasn’t been a single instance where I couldn’t do something conveniently in Linux for the past two months. In fact, for the majority of the stuff I do I felt that Linux was actually easier. There are a few rough edges, of course. For example, copy and paste sometimes do not play well between GNOME and KDE applications and the Flash play back performance under Linux is far inferior then under Windows. But it does not matter to me that much (I block flash content on my Windows PC anyway). 

During the past couple of weeks, I have been playing with Ubuntu 8.04 (Hardy Heron) beta version and I was pretty happy with the results so as soon as Ubuntu 8.04 was released last Thursday, I downloaded the image and installed on my PC.

I am happy to report that Ubuntu 8.04 recognized all the hardware (see the list here) with no issues. And the 2.6.24 kernel fully supports Q9450 and X38 chipset. The included proprietary new nVidia driver supports my 8600 GT graphic card with no problem and I could run Beryl desktop smoothly.

There are a few rough edges however. In beta versions, when I booted Ubuntu, the startup logo was correctly stretched to fit the entire screen (wide screen), but the production code somehow swapped to a 4:3 mode which is kind of annoying. The major issue though is with nautilus. Everything works fine in default mode (icon view), but as soon as I change the settings to list view, dragging and dropping would cause the whole system to lock up. I noticed this behavior in beta builds and had thought that it would be resolved in the production version. So for now, I will use the default setting.

And of course, it happened. Last Thursday evening after installing some routine system updates, I rebooted my computer. But instead of the familiar log-in screen, I was greeted by a seemingly endless reboot. At first, I thought that maybe the latest security updates had messed up something so I hit F8 and tried to boot into safe mode. But again, the computer kept rebooting half-way through the startup process. Since I had Windows XP installed on another hard drive, I booted up XP trying to figure out the problem. And it seemed that the Windows 2003 Server drive had failed. The system seemed to unable to identify the hard drive and I could here the dreadful clicking sound from the Windows 2003 drive.

I powered off my computer immediately. The first thought came across my mind was to create a disk image of the failed drive so that I could always get back to the state right after it failed.

To do this, I booted into SUSE Linux (yet another OS on a third hard drive), and used dd_rescue to create an disk image onto a 320GB external hard drive. Luckily, the drive image was created without any fuss. I then tried to mount the failed disk normally to /windows/D, but it was unsuccessful. After getting a bunch of error messages, the partitioned seemed to be mounted. But the system was only seeing 14G of empty space. I then tried to mount the partition as read-only. After some delay and clicking sound, I was able to do an "ls" and see all the root level contents.

Encouraged, I decided to try to copy everything off the damaged partition to another hard drive in the order of importance. It turned out that the copying speed was extremely slow (averaging around 1MB per minute), every file seek seemed to be accompanied by multiple clicks. Given the speed, it would take three months to totally copy everything off the drive! Luckily, there were only 4GB or so new or modified files since my last backup 2 months ago and till this morning I was able to copy all of those data out.

So, in the end, I did not loose any data. I was lucky enough this time as it seemed that the physical damage occurred at the outer tracks of the drive, where the operating system was. The inner tacks where all my important data was located was largely intact.

The lesson of my experience is that remember to back up your systems regularly, and do not take chances. Modern disks have much higher areal density and you could easily loose gigabytes of data should a drive failure occurs. And do not panic if your hard drive fails. Shut down your system immediately to avoid further damage to the drive. At the early stage of a drive failure, your chance of getting everything back is pretty good. One biggest mistake is to try the failed drive again and again. Doing so may corrupt more data and make a successful recovery more difficult. And of course, do not try to repartition or reformat the drive as doing so would almost certainly make data recovery much more difficult if not totally impossible. And last but not least, if vital data is at stake, you might want to send the drive to a professional data recovery facility as such places have more tools and experience in handling this kind of situation.

After I purchased a 24 inch LCD, I noticed that Ubuntu would not support it’s native 1920×1200 resolution even though it correctly identified my four-years-old ATI Radeon 9200 SE graphics card. I tried many different workarounds (e.g. manually tuning xorg.conf, using ATI native display drivers, etc.) but without any luck. It seems that the maximum resolution I could get under Ubuntu 7.10 is 1280×1024.

So, to keep the long story short, I decided to give the latest OpenSUSE distro (10.3) a try. OpenSUSE uses GRUB as it’s default partition manager. When it was time to reboot after the installation, I was surprised to be greeted by a boot loader error message. Basically, GRUB exited with error number 17. At first I thought that somehow I was not paying enough attention to the partition parameters and somehow chose a boot partition that was too large… instead of monkeying around, I decided to install a second time. But again, I got the same GRUB 17 error message.

This seems to be a rather strange problem as I have been installing Linux for years and have never seen the boot loader failed before. Puzzled, I searched the internet for answers. There are many posts regarding this particular GRUB error, and they seem to suggest that somehow the boot loader failed to recognize the disk’s geometry. I tried a couple of suggestions (one of which seemed really promising, it suggested that this was caused by BIOS reporting the wrong information. It suggested that I disable the DMA settings of the harddrive in BIOS and this would force the boot loader to figure out the disk geometry instead of relying on BIOS), but non seemed to have worked.

Even more puzzled, I decided to go through the installation process again. This time, I chose to use LILO boot loader instead of the default GRUB… and it worked! And best of all, OpenSUSE 10.3 recognized my graphic card (ATI Rage 9200 SE) without any problem and set the resolution correctly to 1920×1200.

It is pretty clear that GRUB has some minor "annoyance" to fix. My PC is equipped with two SATA drives and 1 PATA harddrive. One of the SATA drive is used for Windows XP and I used the PATA drive for Linux installation. So it is possible that this setup is more complex than most of the Linux installations and GRUB had some difficulty figuring out the disk geometries. Nevertheless, LILO still rules.

To use MATLAB 7 under WINE, all one has to do is to copy the harddrive serial number over into ~/.wine/drive_c/.windoes-serial. Here I assume that MATLAB has already been installed under Windows C drive.

The serial number is the disk serial number detected during MATLAB’s installation and can be found under [MATLAB root folder]/bin/win32/license.dat. The value after HOSTID=DISK_SERIAL_NUM= is the serial number.

After setting the disk serial number, MATLAB should be able to be invoked from the shell:

wine /windows/C/MATLAB701/bin/win32/MATLAB.exe

Here is a screen shot of MATLAB 7 running under Suse 10.3 (Gome):

And if the serial number is set incorrectly, the following message will be received instead:

While system crash due to kernel code bugs is rare, ill-behaved user space code can exhaust system resources and cause the system to hang. And to the end user, there is little difference between a blue screen and an unresponsive user interface, and pretty much the only thing he can do is to do a hard reset.

I have seen Linux/Unix systems running for years without requiring reboot. Rogue processes can be killed without affecting the rest of the system. Windows however, has long suffered from the need of requiring frequent reboot. System updates aside, many rogue processes can cause the system appears to hang and there is no efficient way to kill these rogue processes.

To be more concrete, I will use a small Windows command shell program to illustrate my point.

Suppose you have a batch file c:\temp\test.bat and the code is:
@echo off
start /B c:\temp\test.bat
start /B c:\temp\test.bat
{repeat many times here}
start /B c:\temp\test.bat

What this code does is to recursively call itself and fork off as many instances as possible. When you run this code under windows, you will find out that the whole system seems to stop responding. Because the number of instances of cmd.exe grows exponentially, it will exhaust the available handles in a matter of seconds. So when you try to launch the task manager to kill it, you will find yourself waiting forever for the task manager to show up. Since the cmd.exe process is being created at an exponential rate, windows scheduler is having a hard time keeping up the pace and leaving other vital processes to starve. At this point, even though the operating system is still alive, there is not much the user can do except to wait and hope that the scheduler will eventually give task manager a chance to run so that the rogue process can be killed or resort to reboot.

This situation is handled much better in modern Linux/Unix system (note, historically, Unix handled this poorly and lead to the infamous while(1) fork();). Similar to the windows script we used above, the following script can be used for the same purpose under Linux/Unix:

/tmp/test.sh
sh ./test.sh
sh ./test.sh
{repeat many times here}
sh ./test.sh

When test.sh is invoked, it will start invoking sh at an exponential rate. But the user can suspend (Ctrl + Z) the process or use a kill -9 to kill the parent process.

So in this simple test, we can clearly see that process scheduling in Linux/Unix systems is more robust than in Windows. It also illustrates that rogue processes can cause just as much headaches as blue screens do.

And indeed, a whopping 86% of these sites are running Linux or UNIX like operating systems. What is more interesting is that among the 14% that runs on Microsoft Windows, only 2 of them (4%) is running Windows 2003. And of course, one of them is Microsoft.

Of course, these are just the sites I visit most often, I am sure that the statistics vary from person to person, but the picture is quite clear…

My DataStor external enclosure worked great under Windows 95, it supported hot plug and play. I used it under Windows 98 as well. But the driver support became pretty bad under Windows 2000 and made reliable backups virtually impossible. Furthermore, there has been no official support for the drivers since Windows 2000. So the external case has been sitting there gathering dust for at least 6 years now. So I decided to try to find out whether I could utilize these old equipments under Linux.

The Linux distro I used is RedHat 9.0. There’s no particular reason why I chose RedHat 9.0 distro as oppose to SuSE or Mandrake, I just happened to have the CDs lying around. I am pretty sure that almost any Linux distro will be able to do the job.

The installation of RedHat 9.0 went pretty effortlessly. Within an hour, I was able to run it. Amazingly the installation recognized virtually every piece of hardware I had on that laptop. Even KDE loaded up correctly, albeit slow. But I was not concerned about the GUI performance anyway, since I was going to use it as a file server and the configurations could be done in text mode.

Then I set up Samba and was ready to attach my parallel port enclosure. I have a 13G IDE Seagate hard drive from 1999, which is a perfect candidate for the file server.

To get the system recognize my parallel port hard drive turned out to be a little bit more work. Sadly, since the days of parallel enclosures were long passed, the information I could find on the internet was very sketchy. Nevertheless, I found an excellent manual on how to setup parallel port device for running on Linux on http://cyberelk.net/tim/parport/paride.html.

Here are the steps on how to get DataStor parallel port external hard drive to work.

1. Make sure that the parallel port is set to use EPP mode in BIOS (standard mode works also, but is significantly slower). If the BIOS has a setting for whether the computer should support Plug and Play, choose No (Non Plug Play). Since my computer is pretty old, for the OS to recognize the drive geometry properly, I also needed to select Disk Type to be other (e.g. UNIX) instead of DOS (e.g. Windows).

2. Modify /etc/fstab, add the following line so that the external drive can be mounted later:

/dev/pda1 /mnt/hdd ext2 defaults 0 0

3. Log in as root, go to /sbin and type the following command in the given order to setup the parport driver:

modprobe parideinsmod dstrinsmod pd 

And the driver for the external drive is now loaded. To verify take a look using dmesg and lines similar to the following should be in the log:

paride: version 1.06 installed (parport) paride: dstr registered as protocol 0 pd: pd version 1.05, major 45, cluster 64, nice 0 pda: Sharing parport0 at 0×378 pda: dstr 1.01, DataStor EP2000 at 0×378, mode 4 (EPP-32), delay 1 pda: ST313032A, master, 25434228 blocks [12419M], (16383/16/63), fixed media pda: pda1

4. Use mke2fs /dev/pda1 to create a new ex2 file system on the external drive.

5. Suppose you have Samba installed already, you can add a section in your /etc/samba/smb.conf file to enable the share so that Windows machines can see.

6. Finally, run /etc/rc.d/init.d/smb restart so the new Samba setting can take effect.

The speed of the external hard drive is pretty slow (even in EPP mode) compares to the standard we use today. Copying files of mixed sizes resulted in just above 500K per second. But hey, we are talking about a computer that is ten years old here. And for backup usage, the slow speed actually works very well. Because the lower transfer rate at the external hard drive side, there’s no noticeable performance degradation on the computer from which the backup operation is initiated. Who cares how long the backup runs since it would be running in the background anyway…