Saliya's Blogs: C#

Showing posts with label C#. Show all posts

Running C# MPI.NET Applications with Mono and OpenMPI

Saliya Ekanayake

I wrote an earlier post on the same subject, but just realized it's not detailed enough even for me to retry, hence the reason for this post.

I've tested this in FutreGrid with Infiniband to run our C# based pairwise clustering program on real data up to 32 nodes (I didn't find any restriction to go above this many nodes - it was just the maximum I could reserve at that time)

What you'll need

Mono 3.4.0
MPI.NET source code revision 338.
```
  svn co https://svn.osl.iu.edu/svn/mpi_net/trunk -r 338 mpi.net
```
- Also, download the Unsafe.pl.patch, which was originally available here
OpenMPI 1.4.3. Note this is a retired version of OpenMPI and we are using it only because that's the best that I could get MPI.NET to compile against. If in future MPI.NET team provides support for a newer version of OpenMPI, you may be able to use it as well.
Automake 1.9. Newer versions may work, but I encountered some errors in the past, which made me stick with version 1.9.

How to install

I suggest installing everything to a user directory, which will avoid you requiring super user privileges. Let's create a directory called build_mono inside home directory.
```
 mkdir ~/build_mono
```
The following lines added to your ~/.bashrc will help you follow the rest of the document.
```
 BUILD_MONO=~/build_mono
 PATH=$BUILD_MONO/bin:$PATH
 LD_LIBRARY_PATH=$BUILD_MONO/lib
 ac_cv_path_ILASM=$BUILD_MONO/bin/ilasm

 export BUILD_MONO PATH LD_LIBRARY_PATH ac_cv_path_ILASM
```
Once these lines are added do,
```
 source ~/.bashrc
```
Build automake by first going to the directory that containst automake-1.9.tar.gz and doing,
```
 tar -xzf automake-1.9.tar.gz
 cd automake-1.9
 ./configure --prefix=$BUILD_MONO
 make
 make install
```
You can verify the installation by typing which automake, which should point to automake inside $BUILD_MONO/bin
Build OpenMPI. Again, change directory to where you downloaded openmpi-1.4.3.tar.gz and do,
```
 tar -xzf openmpi-1.4.3.tar.gz
 cd openmpi-1.4.3
 ./configure --prefix=$BUILD_MONO
 make
 make install
```
Optionally if Infiniband is available you can point to the verbs.h (usually this is in /usr/include/infiniband/) by specifying the folder /usr in the above configure command as,
```
 ./configure --prefix=$BUILD_MONO --with-openib=/usr
```
If building OpenMPI is successfull, you'll see the following output for mpirun --version command,
```
 mpirun (Open MPI) 1.4.3

 Report bugs to http://www.open-mpi.org/community/help/
```
Also, to make sure the Infiniband module is built correctly (if specified) you can do,
```
 ompi_info|grep openib
```
which, should output the following.
```
 MCA btl: openib (MCA v2.0, API v2.0, Component v1.4.3)
```
Build Mono. Go to directory containing mono-3.4.0.tar.bz2 and do,
```
 tar -xjf mono-3.4.0.tar.bz2
 cd mono-3.4.0
```
Mono 3.4.0 release is missing a file, which you'll need to add by pasting the following content to a file called./mcs/tools/xbuild/targets/Microsoft.Portable.Common.targets
```
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
     <Import Project="..\Microsoft.Portable.Core.props" />
     <Import Project="..\Microsoft.Portable.Core.targets" />
 </Project>
```
You can continue with the build by following,
```
 ./configure --prefix=$BUILD_MONO
 make
 make install
```
There are several configuration parameters that you can play with and I suggest going through them either in README.md or in./configure --help. One parameter, in particular, that I'd like to test with is --with-tls=pthread
Build MPI.NET. If you were wonder why we had that ac_cv_path_ILASM variable in ~/.bashrc then this is where it'll be used. MPI.NET by default tries to find the Intermediate Language Assembler (ILASM) at /usr/bin/ilasm2, which for 1. does not exist because we built Mono into $BUILD_MONO and not /usr 2. does not exist because newer versions of Mono calls this ilasm notilasm2. Therefore, after digging through the configure file I found that we can specify the path to the ILASM by exporting the above environment variable.

Alright, back to building MPI.NET. First copy the downloaded Unsafe.pl.patch to the subversion checkout of MPI.NET. Then change directory there and do,
```
 patch MPI/Unsafe.pl < Unsafe.pl.patch
```
This will say some hunks failed to apply, but that should be fine. It only means that those are already fixed in the checkout. Once patching is completed continue with the following.
```
 ./autogen.sh
 ./configure --prefix=$BUILD_MONO
 make
 make install
```
At this point you should be able to find MPI.dll and MPI.dll.config inside MPI directory, which you can use to bind against your C# MPI application.

How to run

Here's a sample MPI program written in C# using MPI.NET.

  using System;
  using MPI;
  namespace MPINETinMono
  {
      class Program
      {
          static void Main(string[] args)
          {
              using (new MPI.Environment(ref args))
              {
                  Console.Write("Rank {0} of {1} running on {2}\n",
                                  Communicator.world.Rank,
                                  Communicator.world.Size,
                                  MPI.Environment.ProcessorName);
              }
          }
      }
  }

There are two ways that you can compile this program.
1. Use Visual Studio referring to MPI.dll built on Windows
2. Use mcs from Linux referring to MPI.dll built on Linux
```
mcs Program.cs -reference:$MPI.NET_DIR/tools/mpi_net/MPI/MPI.dll
```
  where $MPI.NET_DIR refers to the subversion checkout directory of MPI.NET
  
  Either way you should be able to get Program.exe in the end.
Once you have the executable you can use mono with mpirun to run this in Linux. For example you can do the following within the directory of the executable,
```
  mpirun -np 4 mono ./Program.exe
```
which will produce,
```
  Rank 0 of 4 running on i81
  Rank 2 of 4 running on i81
  Rank 1 of 4 running on i81
  Rank 3 of 4 running on i81
```
where i81 is one of the compute nodes in FutureGrid cluster.

You may also use other advance options with mpirun to determine process mapping and binding. Note. the syntax for such controlling is different from latest versions of OpenMPI. Therefore, it's a good idea to look at different options from mpirun --help. For example you may be interested in specifying the following options,
```
  hostfile=<path-to-hostfile-listing-available-computing-nodes>
  ppn=<number-of-processes-per-node>
  cpp=<number-of-cpus-to-allocate-for-a-process>

  mpirun --display-map --mca btl ^tcp --hostfile $hostfile --bind-to-core --bysocket --npernode $ppn --cpus-per-proc $cpp -np $(($nodes*$ppn)) ...
```
where, --display-map will print how processes are bind to processing units and --mca btl ^tcp forces to turn off tcp

That's all you'll need to run C# based MPI.NET applications in Linux with Mono and OpenMPI. Hope this helps!

9:24 PM C# , linux , Mono , MPI.NET , OpenMPI

C# and Java Operators Thread Safety

Saliya Ekanayake

Java and C# both have compound assignment operators and the increment/decrement operators. For example see http://msdn.microsoft.com/en-us/library/6a71f45d.aspx for a list of C# operators and http://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html for the Java version.

It seems these two step operations, i.e. x op= y, x++, x--, ++x, and --x, are NOT thread safe. It makes sense as these operations require reading the current value of the given variable and then updating it with the computed value. It is possible for threads to interleave between these operations resulting erroneous final values.

There are many ways to guarantee the atomicity in such cases including synchronized blocks, atomic data types such as Java AtomicInteger, and interlocked operations like in C#.

Here are some links that may help,

C# interlocked methods: http://msdn.microsoft.com/en-us/library/System.Threading.Interlocked_methods.aspx

Java atomic classes http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/atomic/package-summary.html

C# library to do threading similar to OpenMP like constructs http://msdn.microsoft.com/en-us/library/dd460717.aspx

A Java alternative OpenMP like parallel constructs https://wiki.rice.edu/confluence/display/HABANERO/Habanero+Multicore+Software+Research+Project

8:55 PM C# , compound assignment operators , concurrency , java , thread safety

C# String Vs Secure String

Saliya Ekanayake

Interesting articles on the subject at,

1.) http://blogs.msdn.com/b/shawnfa/archive/2004/05/27/143254.aspx

2.) http://blogs.msdn.com/b/fpintos/archive/2009/06/12/how-to-properly-convert-securestring-to-string.aspx

In summary, a string object is not the best place to keep sensitive information such as passwords, credit card numbers, etc. due to its nature of not being able to lock in one place of memory, immutability (results multiple copies if modified), and possible page swaps (sensitive data now in tmp files) (see 1). Use SecureString as a solution, but sometimes you may still want to get the unsecured string representation as some APIs still don’t support secure strings (see 2).

While at it, you may also like to read about reading a string securely from console,

3.) http://msdn.microsoft.com/en-us/library/system.security.securestring.aspx

4.) http://stackoverflow.com/questions/3404421/password-masking-console-application

9:53 AM C# , secure string , security

Running MPI.NET Applications with Mono in Ubuntu

Saliya Ekanayake

Sometime back I played around Mono to get some of our parallel applications running on Ubuntu. These applications were C# based and used MPI.NET.

The following blog post is a great starting point with all the details you'll need. So I'll skip the steps, except to point out couple of caveats you need to consider.

http://blog.biophysengr.net/2011/11/compiling-mpinet-under-ubuntu-oneiric.html

automake versions above 1.9 will give you an error when building MPI.NET. May be you can change the make script to work with them, but I found it easy to just install automake1.9 to solve it.
You'll need to add /usr/local/lib to your LD_LIBRARY_PATH. Essentially what you need to do is add this path to /etc/ld.so.conf and run ldconfig as root. See documenation from Mono on this at http://www.mono-project.com/DllNotFoundException
Make sure to do chmod +x to your dlls

11:45 PM C# , linux , Mono , MPI , MPI.NET , tutorial , Ubuntu

ReSharper: Life Saver for Visual Studio Users

Saliya Ekanayake

If you are using Visual Studio for application development then most probably you may have noticed the lack of built-in refactoring support. At least for me it was so obvious, probably because I was used to the rich environment provided by IntelliJIDEA (http://www.jetbrains.com/idea/) for Java development. So finally did some search to see if there's any third party plug-in for Visual Studio on this aspect and guess what! The same guys who build IntelliJIDEA has a plug-in called ReSharper (http://www.jetbrains.com/resharper/). I had no second thoughts to use it based on my experience and it sure changed my clumsy feeling towards Visual Studio :)

Unfortunately it's not free, but if you are doing open source development they give you it for free. Anyway, the cost isn't sky-high to purchase as well.

1:16 PM C# , intellij , resharper , tutorial , visual studio

.NET Naming Conventions

Saliya Ekanayake

A good place to learn about .NET naming conventions.

11:07 PM .NET , C# , tutorial

Funny Infinite Loop with C#

Saliya Ekanayake

What will happen when you run the following C# code? It's a never ending loop. Oh! really? yea, note the "Name" inside set method. I have used uppercase N. Now it will call setter recursively.

Interesting isn't it? :)


public class Person
{
private String name;
public String Name
{
set
{
System.Console.WriteLine("assigning wow");
Name = value;
}
}
}


public class Hello
{
static void Main()
{
Person person = new Person();
person.Name = "wow";
}
}

12:27 PM C#

Subscribe to: Posts ( Atom )

Saliya's Blogs

Running C# MPI.NET Applications with Mono and OpenMPI

C# and Java Operators Thread Safety

C# String Vs Secure String

Running MPI.NET Applications with Mono in Ubuntu

ReSharper: Life Saver for Visual Studio Users

.NET Naming Conventions

Funny Infinite Loop with C#

About Me

Links

Blog Archive

Popular Posts

Labels