Author Archives: apparatusd

Ganglia Monitoring the ARI Cluster

Some screenshots of  the ARI cluster 11 nodes being monitored by ganglia.The node utilization of  load and network activity while running a parallel Monte Carlo simulation.



Leave a comment

Posted by on May 10, 2012 in Uncategorized


Tags: , , , ,


Nonprofit Worldreader gives Kindles to students in sub-Saharan Africa (and is working on a reading app for mobile phones). The organization just published the results of iREAD, its year-long pilot program in Ghana, and many of the findings are promising: Primary school students with access to e-readers showed significant improvement in reading skills and in time spent reading, and the program is cost-effective. The theft rate was “near-zero,” but nearly half the e-readers broke.

USAID funded the Worldreader Ghana study and independent firm ILC Africa did the research. iREAD “involved the wireless distribution of over 32,000 local and international digital books using Kindle e-readers to 350 students and teachers at six pilot schools in Ghana’s Eastern Region between November 2010 and September 2011.”

The full results are here (PDF). Some findings:

  • Kids learned to use e-readers quickly even though 43 percent of them had never used a computer before. Also…

View original post 638 more words

Leave a comment

Posted by on April 29, 2012 in Uncategorized


HPC (High Performance Compute) Cluster with MPI and ArchLinux

The following is a simple guide to setting up a cluster server and nodes using ArchLinux.The advantage of this approach is the flexibility of setting up a computer capable of high speed parallel computation using commodity hardware.
The procedure will be generally similar for most Unix based systems.The preference for Arch is driven by its philosophy of keeping-it-simple.’Simple’ is defined from a technical standpoint, not a usability standpoint. It is better to be technically elegant with a higher learning curve, than to be easy to use, and technically crap.Thus for a base system that will be as lean and fast as possible the minimalist base Arch install is perfect for the task at hand.

Open MPI

The Open MPI Project is an open source MPI-2 implementation that is developed and maintained by a consortium of academic, research, and industry partners. Open MPI is therefore able to combine the expertise, technologies, and resources from all across the High Performance Computing community in order to build the best MPI library available.

Machine setup

This guide assumes:

  • all the machines have been formatted and Arch base system installed according to the guide
  • the machines are connected via a TCP/IP network with the ip addresses and hostnames noted down as they will be required in later steps.
  • each machine has a common login account (in this case baloo)
  • all machines are using the same processor architecture i686 or x86_64

Its always a good idea to get the latest and up-to date Arch system so a quick:pacman -Syu

SSH setup

Open MPI communicates between the nodes and server over a secure connection provided by openssh secure shell.The full details of openssh options can be found from the arch wiki or the main openssh site .Here the bare minimum is given to get a cluster up and running.

Installing openssh

Accomplished by calling:pacman -S openssh
the default configuration for the sshd (server deamon) are enough for our needs.Inspect the /etc/ssh/sshd_config making sure all options are sane then continue.

Generating ssh-keys

To allow the cluster to send communication to the nodes from the server without the password being requested at every instance we shall use ssh-keys to enable the seamless logon.Using the defaults accept as given.No passphrase is selected , although inherently less secure than with one this precludes the need to setup key management via keyring.

Copying Keys to the server

Start the ssh deamon rc.d start sshd on both the server and the slave node and copy the public key from each node to the server.These will all end up in the home directory for our common user /home/baloo/.ssh/
The server publickey ( each of the publickeys copied over from the nodes are then appended to the authorized_keys file at ~.ssh/authorized_keys on the server.To enable two way communication its then possible to copy this file back to all the nodes after.
IMPORTANT:make sure the permissions for the following are all appropriate for reading and writing only by the owner:chmod 700 ~/
chmod 700 /.ssh
chmod 600 authorized_keys

logging into the remote machines via ssh should no longer require a passsword.

NFS setup

OpenMPI requires the programs that are to be run to be in a common location here .Instead of copying the program executable over and over to the slave nodes we set up a simple NFS shared directory with the actual folder on the server from which all the nodes will mirror the contents.

Server Configuration

Create the directory that will be shared /parallel in this instance and edit the /etc/exports to have the file mirrored to the remote nodes
/parallel . . . . . . . *(rw,sync)
and change the ownership permissions for the shared directory to nobody
chown -R nobody.nobody /parallel
edit /etc/conf.d/nfs-common.conf

Client Configuration

Edit /etc/fstab to include the following line so the clients can access the shared /parallel directory /parallel nfs defaults 0 0

Daemons Configuration

Setting the appropriate daemons to launch on start-up simply requires the modification of /etc/rc.conf and adding the appropriate entries.


DAEMONS=(…….sshd rpcbind  nfs-common nfs-server ……)


DAEMONS=(…….sshd rpcbind  nfs-common ……)

OpenMPI setup

With the preliminary setup out of the way we can now install the openMPI package , it comes with inbuilt wrappers for c++ fortran and c additionally the python wrappers can also be installed.It should be installed on both the server and nodes
pacman -S openmpi python-mpi4py python2-mpi4py
*the python wrappers are there if you want to implement the parallel programs in mpi for python

OpenMPI Configuration

To allow Open MPI to know on which machines to run your programs create a hostfile in the default user home directory.if /etc/hosts was set up you can use the host names here otherwise the IP addresses of the machines can work just as well.~/mhosts

#The master node is dual processor machine hence slots = 2
localhost slots=2
#The slave node is a quad core machine hence the slots=4
Or1oN slots=4

Running Programs on the cluster

To run myprogram on the cluster issue the following command from the /parallel directory:$mpirun -n 4 –hostfile ~/mhosts ./myprogram$mpirun -n 4 –hostfile ~/mhosts python

or$mpiexec -n 4 –hostfile ~/mhosts ./myprogram

$mpiexec -n 4 –hostfile ~/mhosts python

Leave a comment

Posted by on April 18, 2012 in code, Harware, Processors, Uncategorized


Tags: , , , ,

DANG on a Cloud

Thats Django, ArchLinux ,Nginx and Gunicorn on an Amazon EC2instance.Getting a server to play around with root access courtesy of Amazon AWS is pretty easy, just sign up provide your credit card details and you are almost ready to go.First things first setting up the server.Theer are plenty of ready-made AMI images floating out there so one is really spoilt for choice , personally my preference is for Archlinux having run the rolling release distro as a primary dev machine for the better part of a decade it seemed right to give it a run as a production server.Loading the instance was pretty straightforward (instructions available on AWS blogs and forums).As with all good Arch systems getting it up to the latest version is as easy as:

pacman -Syu
once the changes have been made to the system and confirmed it time to setup the environment.The deployed app will be deployed within a virtualenv , this has the advantage of keeping the python installation of the app sand-boxed from that running on the system with a simple:

pacman -S virtualenv
then executing
virtualenv /path/to/apps -p /usr/bin/python2
source /path/to/apps/bin/activate
once created install the source control system of choice (assuming the app is being managed by one) or good old sftp can work just as well with filezilla .Once unpacked into its deployment folder
installing the project requirements is a case of :
pip install requirements.txt
pip install gunicorn.
As the gunicorn server will be running embedded from within the django app its a matter of adding it to the file and running it will be:

python run_gunicorn
The final part of the puzzle is the nginx server, lighter than the more resource hungry Apache and way simpler to configure with the editing of one file the nginx.conf to server the static assets from the project .
   upstream app_server {
server localhost:8000 fail_timeout=0;

server {
listen 80 default;
client_max_body_size 4G;
server_name _;

keepalive_timeout 5;

location /static/ {
autoindex on;
alias   /home/path/to/site_media/static/;

location / {
# checks for static file, if not found proxy to app
try_files $uri @proxy_to_app;

location @proxy_to_app {
proxy_pass_header Server;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;

proxy_pass   http://app_server;

error_page 500 502 503 504 /500.html;


The gunicorn server will execute the python thread to a port that the nginx will listen to and server to the world your great new web-app hosted on amazon cloud.
Leave a comment

Posted by on February 11, 2012 in code, Internet & networks, Python


Tags: , , , , , ,

Human Target in less than 90 lines of Code (Python+OpenCV)

Using python and the versatile OpenCV library its possible to get a human detection system in less than 90 lines of code.This assumes a basic knowledge of python and some working knowledge of the OpenCV computer vision library.


The initialization selects whether a camera is to be used or captured image file from the disk,with the inbuilt functions as many cameras as needed can be connected starting from CAM(0) and going up incrementally.

   def __init__(self , typ , fpath):
if( typ == 1 ):
self.capture = cv.CaptureFromCAM(0)
elif( typ == 2 ):
self.capture = cv.CaptureFromFile(fpath)
cv.NamedWindow(“Target”, 1)


Before the human can be detected we have to clear up the artifacts that may reduce the efficiency of our detection algorithms.This involves Gaussian smoothing to eliminate false positives.

The capture is gray-scale converted as this color space can be worked on faster than a full color space and re-sized to a smaller size also for the same added speed in processing.

           # Smooth to get rid of false positives
cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)

# Convert the image to grayscale.
cv.CvtColor(color_image, grey_image, cv.CV_RGB2GRAY)

# scale input image for faster processing
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR)

cv.EqualizeHist(small_img, small_img)


The detection is carried out by utilizing a HaarCascade based on Viola-Jones.After training to detect a specific object of interest , the cascade file (an XML) is loaded with into the HaarDetectObjects function which stores the detected objects as a tuple which when iterated over yields our detected objects position.

cascade = cv.Load(“data/HS.xml”)

faces = cv.HaarDetectObjects(small_img, cascade, cv.CreateMemStorage(0),
haar_scale, min_neighbors, cv.CV_HAAR_DO_CANNY_PRUNING, min_size)

A central point is computed and a rectangle with a bulls-eye.The VideoWriter provides a easy way to capture an recording of the whole program run.

writer = cv.CreateVideoWriter(“output.avi”, cv.CV_FOURCC(‘M’,’J’,’P’,’G’), 15, frame_size)

cv.WriteFrame(writer, color_image)

humans found
Leave a comment

Posted by on February 7, 2012 in Computer Vision, Python


Tags: , , ,

Intro to GIS using MapXtreme Java

Part of a small project i  worked on during the summer using NetBeans and MapXtreme Java.With Google Maps , YahooMaps and Openstreet Maps you are genrally spoilt for choice for mapping  applications to build on.However for a few of the more customizable map applications you can roll your own maps and have a suitable interface built using JavaBeans in no time at all.


MapXtreme Java
Prepared Map (mdf format)

Rolling the code

The MapXtreme beans are based on swing tech so integrating them into any java project isnt that muchof a hassle.Main ones to be aware of are and the ones that will be used :

  • VisualMapJ Bean
  • Map ToolBar Bean
  • Tool Beans
  • LayerControl Bean

The visualmapj displays within its content pane built on MapJ base object from which they all inherit.The MapXtreme components come with buildt in webserver (tomcat) from which the map is loaded and served via jsp.After loading the map and checking that it displays ok on the browser.The next step is serving the data from the webserer to a desktop client.

Loading Map into tomcat webserver

Loading Map into tomcat webserver

and displaying the map in the browser:

Webview of Map

Webview of Map

finally putting the desktop app into shape:

imports added to the top of the app:

import com.mapinfo.beans.vmapj.RendererParams;
import com.mapinfo.beans.vmapj.VisualMapJ;
import com.mapinfo.mapdefcontainer.FileMapDefContainer;
import com.mapinfo.xmlprot.mxtj.ImageRequestComposer;

preparing the colors for the display panel and the map:

int maxColors = ImageRequestComposer.MAX_COLORS_TRUECOLOR;
String mimeType = “image/gif”;
String filename = “working.mdf”; 

introducing the beans to hold the map and the control panel:

VisualMapJ vMapJ = new VisualMapJ();
MapToolBar mapToolBar1 = new MapToolBar();

specifying the address of the server running and the container that will receie the displayed map:

String m_mapxtremeURL = “http://Cass1opeA:8090/mapxtreme482/servlet/mapxtreme”;
FileMapDefContainer fmdc = new FileMapDefContainer(“/home/wakwanza/Cod/Maps/data/”); 

and finally putting it all together in a simple try catch to get our app running:

RendererParams myRendererParams = new RendererParams(m_mapxtremeURL,mimeType);
vMapJ.setStartupMapDefinition(new com.mapinfo.beans.vmapj.MapDefParams(fmdc, filename));
vMapJ.setSize(new Dimension(550,550));
catch(Exception e)

JavaApp pulling map from MapXtreme

JavaApp pulling map from MapXtreme

Leave a comment

Posted by on November 11, 2011 in code, Java, MapXtreme


Curing Writers block

From the journal of applied behavioral sciences comes this gem.Not much can be said about it , really speaks for itself.

more at the jump

Leave a comment

Posted by on February 9, 2011 in Uncategorized