CEOs Blog

Got a perfect (100%) score for this course

Out of about 1,000 students I was one of the ten that won a Xeon Phi 60 core (57 cores application usable) card.

Announcement of the result:

I am pleased to advise that you are one of the lucky winners for the Programming on Supercomputers Short course – congratulations!

Cloudcroft was impressed with your work; you can see their comments below:

Loved the aside, some of the best programming utilising the supercomputer and great documentation.

One of the top students. Congratulations on the Phi.

Final Grade: High Distinction

We are planning to make an announcement on the forums, as well as our upcoming newsletter. We would love to let everyone know what a great job you did, however if you would like to remain anonymous we will of course accommodate your preference.

The forum post looked like:

In June, IT Masters, SGI, Cloudcroft and Charles Sturt University worked together to provide the one-of-a-kind Programming on Supercomputers Masterclass. Students gained access to Cloudcroft’s Tulip Trading supercomputer, which is now #15 in the Top 500 Supercomputer list.

Courtesy of Cloudcroft, ten Xeon Phi cards were awarded as prizes to the top performing students in the course. We’re proud to announce the following winners:
Ying Chan
Alex Hindle
Richard Lane
Regan Russell
Jon Harsem
Bruce Wite
James Seagraves
Thomas Cordingley
Carina Ormeño
(The last winner has requested to remain anonymous.)

This was a highly specialised short course that challenged all our students. We thank them for their support and congratulate all who participated as well as our winners.

The most of the course work was Fortran (F90) and C/C++. However the neural-network assignment was to be done in “R” (with R-Studio).

Some example Neural Network code in R:

install.packages('neuralnet')
library("neuralnet")

#Going to create a neural network to perform sqare rooting
#Type ?neuralnet for more information on the neuralnet library

#Generate 50 random numbers uniformly distributed between 0 and 100
#And store them as a dataframe
traininginput <-  as.data.frame(runif(50, min=0, max=100))
trainingoutput <- sqrt(traininginput)

#Column bind the data into one variable
trainingdata <- cbind(traininginput,trainingoutput)
colnames(trainingdata) <- c("Input","Output")

#Train the neural network
#Going to have 10 hidden layers
#Threshold is a numeric value specifying the threshold for the partial
#derivatives of the error function as stopping criteria.
net.sqrt <- neuralnet(Output~Input,trainingdata, hidden=100, threshold=0.01)
print(net.sqrt)

#Plot the neural network
plot(net.sqrt)

#Test the neural network on some training data
testdata <- as.data.frame((1:50)^2) #Generate some squared numbers
net.results <- compute(net.sqrt, testdata) #Run them through the neural network

#Lets see what properties net.sqrt has
ls(net.results)

#Lets see the results
print(net.results$net.result)

#Lets display a better version of the results
cleanoutput <- cbind(testdata,sqrt(testdata),
                     as.data.frame(net.results$net.result))
colnames(cleanoutput) <- c("Input","Expected Output","Neural Net Output")
print(cleanoutput)

Used OpenMP and MPI used OMP_NUM_THREADS to restrict number of threads, using pragmas like:

#pragma omp for reduction(+:sum)
#pragma omp parallel for reduction(+:sum)

Getting OpenMPI environment information:

    procs = omp_get_num_procs();
    nthreads = omp_get_num_threads();
    maxt = omp_get_max_threads();
    inpar = omp_in_parallel();
    dynamic = omp_get_dynamic();
    nested = omp_get_nested();

Example OpenMP reduction code:

#include 
#include 
#include 

int main (int argc, char *argv[]) 
{
int   i, n;
float a[100], b[100], sum; 

/* Some initializations */
n = 100;
for (i=0; i < n; i++)
  a[i] = b[i] = i * 1.0;
sum = 0.0;

#pragma omp parallel for reduction(+:sum)
  for (i=0; i < n; i++)
    sum = sum + (a[i] * b[i]);

printf("   Sum = %f\n",sum);

}

Using the Intel Trace tools with MPI: