Installing and Running GridGain-1.5.1

Transcription

1 Installing and Running GridGain GridGain Definition GridGain is a grid computing platform for Java. It is developed in Java for Java developers and is a natural extension of the latest Java development methodologies. 2.0 Description of Experiment and Defining Requirements The goal of the experiment is to setup GridGain and run a gridded application on the platform. Hardware Architecture: Dell Dimension 8200 Software Configuration: Processor Intel Pentium 4 1.8GHz RAM 512mb Operating System Fedora Core 6 Installed Software: 1) GridGain obtained free from 2) Java 1.6 obtained free from 3) Eclipse obtained free from 3 Setting up software and hardware This section details how we set up Java 1.6, Eclipse, and GridGain 3.1 Setting up Java 1.6 Installation of Java 1.6 was straightforward. After obtaining the installation (bin) files, we ran the program and Java was installed However, this new installation did not replace the java file in /usr/bin, which is the default command run whenever the java command is issued. Thus, the system continued to use the old java installation. We created a symbolic link in the /usr/bin folder called java that pointed to the location of the newly installed java file. The syntax is sudo ln s <location of new java file> java. This operation would fail if there already is a file called java in /usr/bin. It is wise to rename the current java file before creating the link. The syntax to rename the file would be

2 mv java <new name for java file>. The version of Java installation can be checked by running the command java version. 3.2 Setting up GridGain 1.5 We encountered one problem when we tried to install GridGain. GridGain requires that a JAVA_HOME environment variable be set. This environment variable points to the location of the java installation that GridGain would use. This Java installation has to be version 1.5 or later. To set this environment variable, we added the line export JAVA_HOME=<location of java installation> to the /etc/profile file. After the variable was set, the GridGain installation run smoothly. Running a node of GridGain presented us with new problems. GridGain requires that a GRIDGAIN_HOME environment variable be set. This environment variable points to the installation folder of GridGain. The environment variable is set in the same way as the JAVA_HOME environment variable. The line export GRIDGAI _HOME=<location of GridGain installation> is added to /etc/profile file. In order to give GridGain access to other computers on the network, multicast should be enabled on the local computer. However, multicast is turned off by default. To turn it on, we run the command route add net netmask dev eth0 This however did not fully solve the problem. The local firewall was blocking GridGain s attempts to contact other computers. To turn the firewall off, we run the command sudo /sbin/service iptables stop After these steps, the node started up. 3.3 Setting up Eclipse Eclipse runs without a problem after downloading and extracting it. It should be noted that Eclipse 3 requires Java Experiment Setup and Code We decided to implement a gridded merge sort application. The merge sort algorithm splits the input to sort the items. This makes it an easy algorithm to distribute over several nodes. 4.1 How Merge Sort works The algorithm recursively splits the input array into smaller arrays until each array has a size of one. It then puts the array back together, sorting the items before putting them in the array. How the Gridded Merge Sort works. It recursively splits the input array until the constituent arrays are below a specified size. The arrays are then sent to remote nodes for execution. Each

3 node runs the merge sort algorithm and returns a sorted version of the array it received. These sorted arrays are then merged to form the whole sorted array. 4.2 Programming in GridGain The documentation and API for GridGain can be found at Experiment Setup I used a modified form of the merge sort algorithm implementation found on the site To set up the experiment, we first started up the Eclipse IDE. We created a new Java project. After this, we added the GridGain libraries to the build path of the project. 4.4 Code The merge sort class extends the GridTaskSplitAdapter class. The GridTaskSplitAdapter adapter can be used when jobs can be randomly assigned to available grid nodes. This adapter is sufficient in most homogenous environments where all nodes are equally suitable for executing grid job. Therefore, this is perfect for our needs. The code that does the sorting is readily available on the internet and is omitted from this report. The abstract method split() must controls how the task is split up into jobs. This implementation of the split method recursively splits the array until it reaches a specified size. public Collection<? extends GridJob> split(int gridsize, int[] A) throws GridException List<GridJob> jobs = new ArrayList<GridJob>(array.size()); if (A.length<=10)//add array to list of jobs if it meets the size requirement jobnum++; array.add(a); System.out.println("Job "+ jobnum + (" added")); else //recursively split arrays if size is greater than 10 int mid = A.length/2; int k = mid; int[] B = new int[mid]; int[] C = new int[(a.length-mid)]; for (int i = 0; i<mid; i++)

4 B[i]=A[i]; for (int i = 0; i<(a.length-mid); i++) C[i]=A[k]; k++; split(gridsize, B);//recursively split arrays split(gridsize, C); //recursively split arrays //assign each task to a job for (final int [] arra : array) jobs.add(new GridJobAdapter<int[]>(arra)//create jobs from items in the job list execute results..."); ); public Serializable execute()//code for each job to System.out.println("Sorting... Be patient"); MergeSort.sort(arra); nodecount++; System.out.println("Node "+ nodecount + " for (int i = 0; i<arra.length; i++) System.out.println(arra[i]+ " "); System.out.println(""); return arra; return jobs; When the task is split, each individual task is assigned to a job (GridJobAdapter). Each job executes the code found in the execute method of the GridJobAdapter. This implementation of the execute method calls the sort method of the class. When the job is complete, the results are put in a collection and returned. The reduce method aggregates the job results received from the split method. This implementation of the split method merges the sorted arrays into one sorted array. It uses a helper method called collapse.

5 public Serializable reduce(list<gridjobresult> results) throws GridException //aggregates results from grids int[] sorted = new int[5]; Vector<int[]> store = new Vector<int[]>(); jobs grids for (GridJobResult res : results)//get data from successful grid store.add((int[]) res.getdata()); while (store.size()>2)//merge individual arrays received from collapse(store); if (store.size()<= 2) if (store.size()==2) sorted = new int[(store.elementat(0).length+store.elementat(1).length)]; merge(store.elementat(0), store.elementat(1), sorted); if (store.size()==1) sorted = new int[store.elementat(0).length]; sorted = store.elementat(0); return sorted; private void collapse(vector<int[]> store) int size = store.size(); if (size==2) return; else int[] temp = new int[(store.lastelement().length+store.elementat(size-2).length)]; merge(store.lastelement(), store.elementat(size-2), temp); store.add(size-2, temp); store.setsize(size-1); return ; The gridded merge sort application is complete. All that is required now is the driver. The driver contains the main method. It starts the grid, and tells the grid what to execute. Here is the code for my driver.

6 import java.util.random; import org.gridgain.grid.grid; import org.gridgain.grid.gridexception; import org.gridgain.grid.gridfactory; public class MergeSortExample /** args */ public static void main(string[] args) throws GridException GridFactory.start();//starts the grid a grid try Grid grid = GridFactory.getGrid();//creates an instance of int[] test = new int[1000]; Random jon = new Random(); for (int i=0; i<1000; i++) test[i] = jon.nextint(1000); for (int i = 0; i<test.length; i++) System.out.print(test[i] + " "); test).get(); test =(int[])grid.execute(mergesort.class.getname(), System.out.println("The gridded sort result is..."); for (int i = 0; i<test.length; i++) System.out.print(test[i] + " "); System.out.println(""); finally GridFactory.stop(true);//stops the grid

7 5.0 Results of Experiment To test the setup, I run three GridGain nodes on the host computer. One node run from the Eclipse IDE and the others were standalone nodes. I also run three additional nodes on a Windows machine. I did this to see if GridGain could really distribute across different operating systems. Below are screen shots of the nodes from both machines. The first screenshot is from the host machine. The top two visible windows are the standalone GridGain nodes. The window at the bottom is the node from Eclipse IDE and it displays part of the results of the final sorted array The next screenshot shows the nodes run on the Windows box.

8 The three GridGain nodes and the results of their computation can be seen here. 6.0 Conclusion We were able to achieve the goals we set for ourselves for the experiment. We installed GridGain and successfully run an application on it. GridGain provides a great API for quick development of gridded applications. Anyone who can program in Java can quickly catch on to the GridGain API and be writing applications in no time. As demonstrated by the experiment, the underlying architecture of the remote nodes does not matter to GridGain. It can distribute jobs to remote computers that run different operating systems and have different hardware implementations. This is one of the big advantages of grid computing, and GridGain implements it very well.