Archive for February, 2011

Installing git on a Bluehost Hosting Account

Thursday, February 24th, 2011

I recently upgraded the version of git that I was using on my personal hosting account to the latest version, 1.7.4.1. I was surprised with how easy it was. I am sure that these steps are not that different for other shared hosting companies and plans, but I have only tested them on Bluehost.

  1. Download it: $ wget http://www.kernel.org/pub/software/scm/git/git-1.7.4.1.tar.bz2
  2. Unpack it: $ tar xf git-1.7.4.1.tar.bz2
  3. CD into it: $ cd git-1.7.4.1
  4. Configure it: $ ./configure --prefix=~/git-install
  5. Compile it: $ make
  6. Make a directory for it: $ mkdir ~/git-install
  7. Install it: $ make install
  8. Fix .bashrc so you can use it: Add ~/git-install to the end of your $PATH variable. If there was a line in .bashrc that looked like
    PATH=/bin:/usr/bin:~/bin,
    change it to look like:
    PATH=/bin:/usr/bin:~/bin:~/git-install/bin

Voila, you now have a functioning installation of git on your hosting account! You can use it to keep your website in version control, or do something really wild and use it as a repository server.

Measuring the Overhead of a JNI Call

Thursday, February 10th, 2011

I have been doing a fair amount of work with Java lately, and a lot of it has required me to make system calls to the Linux kernel, via JNI. I got to wondering what the actual overhead of a JNI call is versus the time it takes to execute the C code.

So, I wrote a simple test application (https://github.com/aclindsa/jnioverhead) to test it out for myself.

This application makes two calls to JNI. Each call measures the time stamp counter. In doing so, the difference between the first and second calls would be the overhead of one call (the tail end of the first call, and the first half of the second). I then make the same calls through C, and compare the difference. I then repeat this 1,000,000 times in both Java and C.

I found that on my desktop PC (Core 2 Duo 4400 @2.00GHz, 2GB RAM, Ubuntu 10.04, OpenJDK 1.6, gcc 4.4.3) the difference seems to hover around 150 clock ticks. Making the function calls in C is usually about 275 ticks, and Java is close to 430. Here are the results from a sample run of my code:

Average time in C: 276.22658 ticks (stddev: 641.930900322, min: 270, max: 251470)
Average time in Java: 427.31173 ticks (stddev: 1073.98186333, min: 370, max: 286170)

While JNI obviously isn’t going to be as speedy as raw C, 150 clock cycles isn’t horribly slow either.