WATWP provides Visual Studio template to create Azure backed end Windows Phone apps. Lets start to see its features, assuming you are not having Azure account yet. WATWP will prompt a dialog to choose cloud data storage mode of your application, on Windows Azure Storage, SQL Azure Storage or OData Service. In my case, I will show simple scenario using Windows Azure storage on Visual Studio Storage Emulator.

WATWP template that I used provides push notification services with two options of authentication mechanism – ASP.NET Membership or Azure ACS. I used the membership version in this walkthrough. Make sure that you do not have any Web site running in ports 443 and 10080 on your local IIS before continue.

Just continue if you get certificate error until you get the landing ASP.NET page (administration page). To log into the Web application use the following credentials:

User Name: admin
Password:  Passw0rd! (with a zero)

   

Once you logged in, you will get the page that manage Azure Storage (Table, Queue and Blob) and Microsoft Push Notifications. Let see on the Windows Phone project solution – build and debug it. The app will redirect us to the log in page. If we click log on, that will open IE in the Windows Phone Emulator at http://127.0.0.1:10080/127.0.0.1.cer. Once logged in Windows Phone emulator, you can enable push notification.

     

Once push notification enabled on Windows Phone (or emulator), the device will be connected to Microsoft Push Notification Service. You can logon the web administration to send notification messages.

You can also do Toast and Tile – where you can push notification from Administration page to device.

Many more features on WAT-WP. Stay tune till the closing – 7 hours to go. I hope I can close our 24 hour session by explaining Windows Azure toolkit for WP !! Love and proud to all of you. You will get more info if you attend my session in the morning, I will show to to extend the WAT for your custom apps with Azure backend!.

Keep wake up, stay tune!

Cheers – Risman Adnan

To enable smooth streaming service in your IIS Web Server, you have to make sure that you have Media Service is installed.

Once you installed both Server and Tools, you are ready to go with this walkthrough. There are 3 major steps you need to follow:
1. Prepare encoded video using Expression Encoder
2. Publish encoded video to IIS for HTTP access
3. Create Windows Phone client video player

Lets start with the step 1 to prepare the video using Expression Encoder.


Prepare Encoded Video using Expression Encoder

Smooth Streaming, an IIS Media Services extension, enables adaptive streaming of media to Silverlight and other clients over HTTP. Smooth Streaming uses simple concept of delivering small content fragments (typically 2 seconds worth of video) and verifying that each has arrived within the appropriate time and played back at the expected quality level. If one fragment doesn't meet these requirements, the next fragment delivered will be at a somewhat lower quality level. Conversely, when conditions allow it, the quality of subsequent fragments will be at a higher level. To create Smooth Streaming presentations, the source content (video or audio) is encoded using Expression Encoder then content is delivered using a Smooth Streaming-enabled IIS web server. First, open you Expression encoder – choose Silverlight Project - then import your source video to Expression Encoder (in my case, wpVideo01.wmv). For Windows Phone client, you have to apply VC-1 IIS Smooth Streaming – SD 480p VBR - No bit rate encoding support for Windows Phone so far, but it may appear in future. After you apply, you can choose Thumbnail and your encoded job output location.

  

If all is ready, then you can start encoding using Encode button. It will take some time to finish, depend to the size of encoded source and the capacity of your computer. After encoding process finished, Expression encoder will prompt you a landing page where you can test your video browser. It means, the presentation files of smooth streaming are ready at job output location.

Here is the files generated by Expression Encoder. Default.html is the landing page for test, *.xap is Silverlight player template, IIS Smooth Streaming encoded files (fragmented videos with different bit rate), ISM and its configuration XML files. ISM is a XML file that contain stream index of video fragments. The manifest can be accessed through web browser http://localhost/[]/wpVideo01.ism/manifest.

Now lets move to step #2 to publish the presentation files to IIS Web server.

Publish Encoded Video to IIS for HTTP Access

We have to create Website or Web Application in IIS to host the presentation files. Go to IIS manager, right click on Default Website and add Application. Specify the Alias of your web application (NokiaDemo) and location of presentation files (Expression encoder job output location where video fragments and ISM file located). Test the manifest by access following URL: http://localhost/NokiaDemo/wpVideo01.ism/manifest until you can read the manifest. You can also test the video in browser using the Default.html file given by Expression Encoder : http://localhost/NokiaDemo/Default.html.

If everything went well, you are ready to go with step #3, to create a video player. It will require your coding skill, little bit!.

Create Windows Phone Client Video Player

The good news is, Microsoft already prepare framework and reusable components for you to utilize. Not build from zero. There are two options, using the IIS Smooth Streaming Client 1.5 APIs (available on WPI 3.0 or download here) or using the Microsoft Media Platform: Player Framework (MMPPF) – an open source version. IIS Smooth Streaming Client 1.5 API is a core component of MMPPF.  Both provide an easy-to-use interface for developers and designers to create rich Smooth Streaming experiences using the Microsoft Silverlight platform on Windows Phone device. If you prefer to use Smooth Streaming Client 1.5 APIs, you can download simple demo player here that utilized the DLLs. What I will show you in this post is using MMPPF, that you can download the source code version at SMF Codeplex site. While writing this post, I am using microsoft-smf-src-2.2011.1101.0. To compile from source codes, you can open SilverlightMediaFramework.Phone.sln file in Visual Studio then Rebuild the solution. You have a very nice sample application inside the solution, Microsoft.SilverlightMediaFramework.TestPhone, that accesses to 2 Channel9 video manifests:

http://ecn.channel9.msdn.com/o9/content/smf/smoothcontent/bbbwp7/big buck bunny.ism/manifest
http://ecn.channel9.msdn.com/o9/content/smf/smoothcontent/edwp7/Elephants_Dream_1024-h264-st-aac.ism/manifest 

If you have internet connection, you can debug and test it in your Windows Phone emulator. Big Buck Bunny and Elephants Dream are Smooth Streaming while the Wildlife is a simple progressive download. You can experience the different between Smooth Streaming and Progressive download model from this sample application.

I’m going to show you how to create simple player using MMPPF for wpVideo01 file that we already encoded and published in step #1-2. The result of your SMF compilation for Windows Phone will be located at wpbin directory. Create a Phone Silverlight Application in Visual Studio add reference to the following DLL: 

- Microsoft.Web.Media.SmoothStreaming.dll
- Microsoft.SilverlightMediaFramework.Core.Phone.dll
- Microsoft.SilverlightMediaFramework.Plugins.Phone.dll
- Microsoft.SilverlightMediaFramework.Utilities.Phone.dll
- Microsoft.SilverlightMediaFramework.Compatibility.Phone.dll
- Microsoft.SilverlightMediaFramework.Plugins.SmoothStreaming.Phone.dll

Choose your Windows Phone OS version, in my case I’m using WP OS 7.1 (Mango). After project created, add reference to the DLLs.

Add the following namespace into your MainPage.xaml file:

xmlns:Core="clr-namespace:Microsoft.SilverlightMediaFramework.Core;assembly=Microsoft.SilverlightMediaFramework.Core.Phone"
xmlns:Media="clr-namespace:Microsoft.SilverlightMediaFramework.Core.Media;assembly=Microsoft.SilverlightMediaFramework.Core.Phone"
xmlns:ssme="clr-namespace:Microsoft.Web.Media.SmoothStreaming;assembly=Microsoft.Web.Media.SmoothStreaming"

Then add a player on the page to play stream media by the following codes on content Grid.

<StackPanel Orientation="Vertical">
    <TextBlock Text="WP7 Smooth Streaming Demo" Height="22" Width="266" FontSize="12" Foreground="Blue"/>
    <Core:SMFPlayer Name="strmPlayer"
        HorizontalAlignment="Stretch"
                     Margin="0"
                     VerticalAlignment="Stretch"/>
</StackPanel>

Last, you need to write some C# code on the MainPage.xaml.cs, to create a play list of streamed media and play in the player.

using System;
using Microsoft.Phone.Controls;
using Microsoft.SilverlightMediaFramework.Core.Media;

namespace Streaming
{
    public partial class MainPage : PhoneApplicationPage
    {
        // Constructor
        public MainPage()
        {
            InitializeComponent();
            PlaylistItem item = new PlaylistItem();
            item.MediaSource = new Uri("http://localhost/NokiaDemo/wpVideo01.ism/manifest");
            item.DeliveryMethod = Microsoft.SilverlightMediaFramework.Plugins.Primitives.DeliveryMethods.AdaptiveStreaming;
            strmPlayer.Playlist.Add(item);
            strmPlayer.Play();
        }

    }
}

Make sure that you put the right MediaSource URI then you are done!.  

I hope this walkthrough demo is useful for you. You can try many more features in the MMPPF by looking into the sample application.

Cheers – Risman Adnan

I will be delivering 2 Azure developer talks in Hanoi and Saigon. Happy to be there one more time.

Cheers - RAM

The next step for me is to develop end-to-end solution architecture in managing RIA based application like this. After looking around for design practices, I found that Microsoft .NET RIA Services is good as our base line. This is now available and you can download and later explore it like I do. In this post, I would like to encourage you to see that we can add additional scenarios, making RIA Services really applicable in limited bandwidth condition – adding offline feature. From marketing point of view:

Microsoft .NET RIA Services simplifies the traditional n-tier application pattern by bringing together the ASP.NET and Silverlight platforms. RIA Services provides a pattern to write application logic that runs on the mid-tier and controls access to data for queries, changes and custom operations. It also provides end-to-end support for common tasks such as data validation, authentication and roles by integrating with Silverlight components on the client and ASP.NET on the mid-tier.

From technical point of view (you can read more from its PDF documentation). It is a framework that provides patterns for writing LOB application logic and validation (by design). LOB applications use data that needs to flow across tiers. It may be created and used through basic CRUD operations or it may be accessed through domain-specific custom operations in encapsulated form such as an approval operation. In an internet application, there is a trust boundary between the client and the mid-tier server. Hence, it is important to have a stylized way to express what resources are available to the client tier and what operations are permitted. In addition to defining the resources and operations, a developer needs to validate the data as it is created or updated. The validation needs to run on the presentation tier for giving immediate feedback to the user and on the mid-tier for ensuring that the rules defined for the application are enforced. Thus, there may be common validation across the tiers as well as tier-specific validations that need to be integrated with the resources and operations.

Lets look at the anatomy of a common Web application compared to RIA. With a RIA, most of the presentation logic moves to the client to improve the UX and to make effective use of local state. The result is additional work for the developer: defining a full-fledged services layer, new types and contracts to share etc. and continually evolving them as the app evolves on either end. A RIA isn't just a client app, but an "Internet" app that includes a server component. This is where RIA Service guidance will give you values – end-to-end pattern for this additional work. But remember, there is no perfect design/pattern, we can always improve it based on our requirements.

The first part of RIA Services pattern is to write a DomainService class. This represents your application domain, your application logic, or business logic, a set of operations – CRUD based or custom domain-specific, DAL specific, authorization and validation. A DomainService is optimized to be stateless - to respond to query requests and to change set processing requests.

The second part of the pattern is what we generate - the client-side data model - in a DomainContext class. This class represents the view of what the client can see. It contains lists of objects, one for each type exposed to the client, and it contains a set of load methods that roughly correspond to the queries exposed on the service. These load methods can be used to load objects into the corresponding lists. The individual objects and lists track changes and raise change notifications. The DomainContext can extract all the changes, create a change set and submit it to the service for processing and committing. A DomainContext is optimized for taking advantage of the stateful environment and to be a well-behaved citizen in a binding-centric presentation technology such as Silverlight or WPF.

Nikhil Kothari describe .NET RIA Services vision as RAD for RIA, which is I totally agreed and have the same sense.But there is one requirement here in Asia that we must consider – low bandwidth condition. This will rise new scenario - offline-enabled RIA application, means that we need to add local storage scenario for the DomainContext. The design challenges of all the offline-enabled applications are:

How to isolate client data layer

What is actually the data layer in RIA? It that the API that server exposes to AJAX? Gears provides a good vision on Server Data Layer and Local Data Layer, controlled by a Data Switch. Gears propose JavaScript DB API with SQLite to enable local data storage. It is a good project to start with SQL Compact Edition, however, but an ActiveXObject should be created for SQL Compact Edition/SQL Express/ESENT. Anyone interested here?

Offline strategy – what features need offline scenario

This is the harder part for me, as closely related to our application scenarios. Some numerical calculation should be done at client side and its results should be store locally in order to feed parameters for responsive and dynamic GUI animation. You might think that you would always want to use the local store since it is faster. However, there are many practical reasons why you may want or need to access the data on server instead. For instance:

- Data may be so transient in nature that it makes no sense to cache it. I will use Project Velocity for cache anyway.
- Some Simulation's data makes sense only while online.
- The App may choose to store only the most frequently accessed data.
- Numerical computational and/or disk space requirements make it unfeasible to recreate the feature offline.

Typically, the optimal solution is to use the local store as much as possible, since it's usually faster than a remote connection. However, the more work an application does locally, the more code you need to write to implement the feature locally and to synchronize the corresponding data. There is a cost/benefit tradeoff to consider, and some features may not be worthwhile to support locally.

In fact, .NET RIA Service provide ready to extend set of capability that I like. But, a lot of work should be done to make it work like I want. That is my problem though :).

Application Modality

What is modality – feature to switch from online to offline states or vice versa. Modal applications usually indicated through some change in the UI. The user is made aware of the state and participates in switching states in some manner. Modeless applications attempt to transition seamlessly between online and offline states, without significant UI changes. The user does not need to participate in switching states, which the application does automatically.

In a modal application, when the application is online it communicates with the server. When it's offline, it uses the local store. Data must be synchronized when the app switches between modes. The advantage of making a modal application is that it's “relatively simple” to implement and therefore a reasonable way to bootstrap the application to function offline. But some disadvantages are: The user must decide and remember to switch modes. Since the local store is not always up-to-date, it can't be used to improve the application's responsiveness when connected to the server.

Data Synchronization

What is the sync strategy for this kind of application? No matter which connection and modality strategy we use, the data in the local database will get out of sync with the server data. For example, local data and server data get out of sync when:

- The user makes changes while offline
- Data is shared and can be changed by external parties
- Data comes from an external source

There are many approaches to synchronization and none are perfect for all situations. We have Microsoft Sync Framework and Astroria Offline as candidates for reusable framework here (where I am still arguing). The most important thing for engineer to decide is manual or background synchronization. In manual sync user decides when to synchronize. It can be implemented simply by uploading all the old local data to the server, and then downloading a fresh copy from the server before going offline. In background sync, the application continuously synchronizes the data between the local data store and the server. This can be implemented by pinging the server every once in a while or better yet, letting the server push or stream data to the client. With Silverlight supports on WCF, this should be easy to implement.

Well, the next step for me is to gather our detail requirements and see how current frameworks can help. I am still hacking the MSF, Astoria Offline, RIA Services, and Velocity. For sure, I will share with you if I found interesting things.

Hope this helps!

Cheers – RAM

#include<iostream>
#include<mpi.h>
using namespace std;

int main(int argc, char** argv){

    int mynode, totalnodes;

    MPI_Init(&argc, &argv); 
    MPI_Comm_size(MPI_COMM_WORLD, &totalnodes);
    MPI_Comm_rank(MPI_COMM_WORLD, &mynode);
    
    cout << "Hello world from process " << mynode;
    cout << " of " << totalnodes << endl;

    MPI_Finalize();
    return 0;
}

7 – Build your first program and if no error found, you can test it by running MPIEXEC (MPI launcher) :

mpiexec –n 10 MyMPIProject.exe

It will create 10 independent processes (you can say 10 nodes), without communication between nodes applied for now. I will discuss later about the inter-process communication inside MPI. The normal result of your program will be:



Congratulation is you reach this stage. You are ready to learn deeper about MS-MPI!.

Cheers – RAM

For practical programmers

I always believe that bottom-up learning approach is the best way to learn programming. MPI is not really complex APIs, but you will not program in vacuum. Understanding about computer architecture and Windows APIs itself will be a great asset. For you who want to advance your native Win32 (Windows API), I would recommend my current readings:

I hope you enjoy MPI exploration like I do.

Happy learning – RAM

using System;

class SequentialPi
{
    static void Main(string[] args)
    {
        int dartsPerProcessor = 10000;
        Random random = new Random();
        int dartsInCircle = 0;
        for (inti = 0; i<dartsPerProcessor; ++i)
        {
            double x = (random.NextDouble() - 0.5) * 2;
            double y = (random.NextDouble() - 0.5) * 2;
            if (x * x + y * y <= 1.0)
                ++dartsInCircle;
        }

        Console.WriteLine("Pi is approximately {0:F15}.",
                          4*(double)totalDartsInCircle/(double)dartsPerProcessor);
    }
}

What MPI Can Do To Parallelize The Codes?

In a message-passing system like MPI, different concurrently-executing “processes” communicate by sending/receiving messages from one to another over a network. Each of the MPI processes has its own, local program state that cannot be observed or modified by any other process except in response to a message.  Most MPI programs are written with the Single Program, Multiple Data (SPMD) parallel model, where each of the processes is running the same program but working on a different part of the data. MPI allows us to launch the same program across many nodes with single command. Initially, each of the processes is identical, with one distinguishing characteristic: each process is assigned a rank, which uniquely identifies that process. The ranks of MPI processes are integer values from 0 to P-1, where P is the number of processes launched as part of the MPI program. MPI processes can query their rank, allowing different processes in the MPI program to have different behavior, and exchange messages with other processes in the same job via their ranks.

Now look on PI sequential program, the more darts we throw, the better the approximation to PI. To parallelize this program, we'll utilize MPI to run several processes, each of which will throw darts independently. Once all of the processes have finished, we'll sum up the results (the total number of darts that landed inside the circle on all processes) to compute PI. The complete code for the parallel calculation of PI is as following:

using System;
using MPI;  // add reference to message passing interface namespace before add this line

class ParallelPI
{
    static void Main(string[] args)
    {
        int dartsPerProcessor = 10000;
        using (new MPI.Environment(ref args))
        {
            if (args.Length > 0)
                dartsPerProcessor = Convert.ToInt32(args[0]);
            Intracommunicator world = Communicator.world;
            Random random = new Random(5 * world.Rank);
            int dartsInCircle = 0;
            for (int i = 0; i < dartsPerProcessor; ++i)
            {
                double x = (random.NextDouble() - 0.5) * 2;
                double y = (random.NextDouble() - 0.5) * 2;
                if (x * x + y * y <= 1.0)
                    ++dartsInCircle;
            }

            if (world.Rank == 0)
            {
                int totalDartsInCircle = world.Reduce<int>(dartsInCircle, Operation<int>.Add, 0);
                System.Console.WriteLine("Pi is approximately {0:F15}.",
                    4*(double)totalDartsInCircle/(world.Size*(double)dartsPerProcessor));
            }
            else
            {
                world.Reduce<int>(dartsInCircle, Operation<int>.Add, 0);
            }
        }
    }
}

1st step in MPI program is to initialize MPI environment by creating a new instance of MPI.Environment within Main method, passing the new object a reference to our command-line arguments. The entire MPI program should be contained within the using statement, which guarantees that the MPI environment properly created and disposed. All valid MPI programs must both initialize and finalize the MPI environment. Reference to command-line arguments, args, is ok because some MPI implementations are permitted to use special arguments to pass state information in to the MPI initialization routines.

After MPI environment initialized, then we can create Communicator object.  MPI communicators are the fundamental abstraction that permits communication among different MPI processes, and every non-trivial MPI program will make use of some communicators. Each communicator representations a self-contained communication space for some set of MPI processes. Any of the processes in that communicator can exchange messages with any other process in that communicator, without fear of those messages colliding with any messages being transmitted on a different communicator.

The PI program above is very simple because we used basic skeleton of MPI program to separate the process from rank 0 and other ranks. The skeleton of giving one of the processes (which is often called the "root", and is typically rank 0) a slightly different code path than all of the other processes is relatively common in MPI programs, which often need to perform some coordination or interaction with the user. Then there are two properties of communicators we used in our PI program: the rank of the process within the communicator, which identifies that process (world.Rank), and the size of the communicator, which provides the number of processes in the communicator (world.Size).

Intraommunicator world = Communicator.world;
if (world.Rank == 0)
{
    // program for rank 0 (root process)
}
else // not rank 0
{
    // program for all other ranks
}

Now we can compile PI program then try to run it using MPIEXEC launcher (inside HPC Pack 2008 or MPICH2). For example we want to run the codes in 10 processes, just type:

MPIEXEC –n 10 ParallelPI.exe

Cheers – RAM

HPC Kit 2008 is a great collection of technical documents, presentations and training for developer and IT Professionals. Everything you need to get started with Windows HPC Server 2008 in one convenient place. Download here.

Windows HPC Server 2008 includes the Microsoft HPC Pack 2008 SDK that currently contains:
- MPIEXEC                                      : MPI Application Launcher
- SMPD                                           : MPI Process Manager
- MPISYNC                                      : MPI Trace Clock Synchronizer
- Microsoft.Hpc.VSDeployTool         : MPI Deployment Tools for Visual Studio
- ELT2CLOG and ETL2OTF              : MPI ETL Trace Converter
- MPI Scheduler API DLLs
- MPI Header and Library Files for i386 and AMD64
- Network Direct Service Provider Interface
 
We can use to Scheduler API to write client applications that interact with the job scheduler but note that we can use the SDK to schedule jobs on Microsoft HPC Server 2008 and later servers only; we cannot use this SDK to schedule jobs on Microsoft Compute Cluster Server 2003 (CCS).   

Please start to download the HPC Kit 2008 and explore about parallel computing using MS-MPI. I will post more tutorial about parallelism on Microsoft platform in this MSDN community. Stay tuned!

Cheers – RAM

In this post, I would like to introduce you to MPI using MPICH2 from Argonne National LAB before jumping into detail of MSMPI inside Windows HPC Server 2008. Learning directly from MPICH2 is good foundation for you because MPICH2 is distributed as source (open-source and free license) and has been tested on several platforms, including Windows (32 and 64 bit). MPICH2 documentations are freely available here too. My goals in this post is to explain you how to start with MPICH2 and create your first MPICH2 C++ program. 

What you need to do is download and install MPICH2 first, then you will have all the header files (*.h), libraries (*.lib) and MPIEXEC.EXE to run jobs. Before you do that, please install the MPICH2 Process Manager by running SMPD.EXE –install. There are many other options for SMPD that you can learn from –help option. SMPD will be installed as Windows Services and you can manage it using SMPD.EXE tool itself or using services.msc.

The MPI-2 Standard describes MPIEXEC as a suggested way to run MPI programs. Sample form of a command to start an MPI job is MPIEXEC -n 32 [yourprogram], which means you want to start your program with 32 processes (providing an MPI COMM WORLD of size 32 inside the MPI application). The -configfile argument allows one to specify a file containing the specifications for process sets on separate lines in the file. This makes it unnecessary to have long command lines for MPIEXEC. Please refer to MPICH2 User Guide about all options of MPIEXEC. In Windows HPC 2008 Server, you will have nicer MPI launcher to help you run MPI programs.


Compiling MPICH2 Source Codes in Windows Server 2008

Now lets learn how to compile the MPICH2 from its source codes. You will need Perl to do that because mpi.h and other header files will be generated automatically using Perl script. I am using Windows Server 2008 x64 with Visual Studio 2008 installed and ActivePerl. To enable you compile MPICH2 source codes, download and extract its source codes from Argonne LAB, then run a file called winconfigure.wsf. That script will generate required header files depend to your configuration. Once finished, open the visual studio solution project (*.sln) and try to compile. I believe you will find around 50 errors of:

_vsnprintf': attributes inconsistent with previous declaration   

in your first compilation, to solve it, please find the following config header (I’m using x64):

..\MPICH2-1.0.8\src\include\win64\mpichconf.h

Then change the codes like below:

#if not defined(_MSC_VER) || defined(__MINGW32__)
   #define snprintf _snprintf
   #define vsnprintf _vsnprintf
#endif

If you are using 64 bit machine like me, make sure you change the include directory that contains mpich2conf.h in all projects properties (initially in win32 folder) then you can try to compile ch3sock, ch3shm, ch3sshm, ch3ssm, and ch3ib projects (release or debug). The last part of the compilation is doing a solution build with the Release or Debug configuration to build MPICEXEC and SMPD. The mpich2 dlls can be built to use shared memory communication, tcp socket communication, or both.

- Select the ch3sockDebug or ch3sockRelease configurations to build the sockets only dlls.
- Select the ch3shmDebug or ch3shmRelease configurations to build the shmem only dlls.
- Select the ch3sshmDebug or ch3sshmRelease configurations to build the scalable shmem only dlls.
- Select the ch3ssmDebug or ch3ssmRelease configurations to build the sockets+shmem dlls.
- Select the ch3ibDebug or ch3ibRelease configurations to build the infiniband dlls.

I hope you are done with the compilation, now lets start to see the simplest MPI program to calculate pi value:

// This is an interactive version of cpi
#include "mpi.h"
#include <stdio.h>
#include <math.h>

double f(double);

double f(double a)
{
    return (4.0 / (1.0 + a*a));
}

int main(int argc,char *argv[])
{
    int done = 0, n, myid, numprocs, i;
    double PI25DT = 3.141592653589793238462643;
    double mypi, pi, h, sum, x;
    double startwtime = 0.0, endwtime;
    int  namelen;
    char processor_name[MPI_MAX_PROCESSOR_NAME];

    MPI_Init(&argc,&argv);
    MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
    MPI_Comm_rank(MPI_COMM_WORLD,&myid);
    MPI_Get_processor_name(processor_name,&namelen);

    /*
    fprintf(stdout,"Process %d of %d is on %s\n", myid, numprocs, processor_name);
    fflush(stdout);
    */

    while (!done) {
        if (myid == 0) {
            fprintf(stdout, "Enter the number of intervals: (0 quits) ");
        fflush(stdout);
            if (scanf("%d",&n) != 1) {
        fprintf( stdout, "No number entered; quitting\n" );
        n = 0;
        }
        startwtime = MPI_Wtime();
        }
        MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
        if (n == 0)
            done = 1;
        else {
            h   = 1.0 / (double) n;
            sum = 0.0;
            for (i = myid + 1; i <= n; i += numprocs) {
                x = h * ((double)i - 0.5);
                sum += f(x);
            }
            mypi = h * sum;
            MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);

            if (myid == 0) {
                printf("pi is approximately %.16f, Error is %.16f\n",
                       pi, fabs(pi - PI25DT));
        endwtime = MPI_Wtime();
        printf("wall clock time = %f\n", endwtime-startwtime);          
        fflush( stdout );
        }
        }
    }
    MPI_Finalize();
    return 0;
}

I will explain more about all the MPI codes in my in coming posting. For now, just try to install, compile and try your first MPI program (like cpi). Let me know if you have problem in compilation.

Cheers – RAM

OpenMP uses Fork-Join Model of parallel execution. Every OpenMP program begins as a single process: called it master thread. The master thread will be executed sequentially until the first parallel region construct is encountered. Most of constructs in OpenMP are compiler directives, with the following structure:

#pragma omp construct [clause [clause] …]

In C/C++ general code structure of the simplest OpenMP program is using omp.h directive and #pragma omp. You have to look on OpenMP documentation in MSDN library for complete construct options in MS VC++ then use /openmp option to compile your program.

#include <omp.h>
#include <iostream>
using namespace std;

int main ()  {

int nthreads, tid;

/* Fork a team of threads giving them their own copies of variables */
#pragma omp parallel private(tid)
  {
  /* Obtain and print thread id */
  tid = omp_get_thread_num();
  cout << "Hello World from thread = " << tid << endl;
  /* Only master thread does this */
  if (tid == 0)
    {
    nthreads = omp_get_num_threads();
    cout << "Number of threads = " << nthreads << endl;
    }

  }  /* All threads join master thread and terminate */

}

Please remember to include omp.h because all function prototypes and types are there. Using OpenMP to parallelize an application is “not hard” as modifications to the original source program are often needed in just a few places. Moreover, one usually does not need to rewrite significant portions of the code. So In general, the effort of parallelizing a program with OpenMP goes mainly into identifying the parallelism, and not in reprogramming the code to implement that parallelism. Let me show you how to use OpenMP to parallelize a simple operation that realizes a very basic problem: multiplying an m x n matrix B with a vector c
of length n, storing the result into a vector a of length m. Here is the formula:

The sequential codes will look like:

void multiplyer(int m, int n, double *a, double *b, double *c)
{
    int i, j;
    for (i=0; i<m; i++)
     {
        a[i] = 0.0;
        for (j=0; j<n; j++) a[i] += b[i*n+j]*c[j];
    }
}

Lets review the codes before parallelizing it. As you can see no two dotproducts compute the same element of the result vector and also the order in which the values for the elements a[i] for i = 1, . . . , m are calculated does not affect correctness of the answer. In other words, this problem can be parallelized over the index value i.

Data in an OpenMP program either is shared by the threads in a team, in which case all member threads will be able to access the same shared variable, or is
private. For private case, each thread has its own copy of the data object, and hence the variable may have different values for different threads. In our case, we want each thread will access the same variable m,n,a,b,c, but each will have its own distinct variable i and j. A single #pragma (directive) is sufficient to parallelize the multiplyer.

void multiplyer(int m, int n, double *a, double *b, double *c)
{
    int i, j;

    #pragma omp parallel for default(none) shared(m,n,a,b,c) private(i,j)
    for (i=0; i<m; i++)
     {
        a[i] = 0.0;
        for (j=0; j<n; j++) a[i] += b[i*n+j]*c[j];
    }
}

You can continue your OpenMP exploration by reading this tutorial. If you prefer to read books, I would like to recommend you the following books from MIT Press. I will post more about parallel computing later.

Cheers – RAM