MANAJEMEN LINGKUNGAN MPI

A. Tujuan

Menguasai rutin-rutin manajemen lingkungan dalam MPI

B. Peralatan yang digunakan

• Visual Studio 2013 Express
• Microsoft HPC Pack 2012
C. Landasan teori

Manajemen lingkungan MPI digunakan untuk menginterogasi dan pengaturan lingkungan eksekusi
MPI, dan meliputi berbagai macam tujuan, seperti inisialisasi dan mengakhiri lingkungan MPI, query
identitas rank, query versi pustaka MPI, dan lain-lain.

D. Eksperimen

Buatlah seluruh program paralel di bawah ini dan jelaskan dalam laporan praktikum.

D.1 Pengaktifan:

1
#include <iostream>
#include <mpi.h>
using namespace std;
int main()
{
int argc, awal;
char **argv;
awal=MPI_Init(&argc, &argv);
cout << "Hello, World" << endl;
return 0;
}

2
#include <iostream>
#include <mpi.h>
using namespace std;
int main()
{
int argc, awal, akhir;
char **argv;
awal=MPI_Init(&argc, &argv);
cout << "Hello, World" << endl;
akhir=MPI_Finalize();
return 0;
}

3
#include <iostream>
#include <mpi.h>
using namespace std;
int main()
{
int awal, flag=0;
awal=MPI_Initialized(&flag);
if (flag)
{
cout << "MPI_Initialized berlogika true" << endl;

19
 return -1;
}
else
{
cout << "MPI_Initialized berlogika false" << endl;
return -1;
}
return 0;
}

4
#include <iostream>
#include <mpi.h>
using namespace std;
int main()
{
int akhir, flag=0;
akhir=MPI_Finalized(&flag);
if (flag)
{
cout << "MPI_Finalized berlogika true" << endl;
return -1;
}
else
{
cout << "MPI_Finalized berlogika false" << endl;
return -1;
}
return 0;
}

5
#include <mpi.h>
using namespace std;
int main()
{
MPI_Comm comm=MPI_COMM_WORLD;
int argc, awal, batal, errorcode=911;
char **argv;
awal=MPI_Init(&argc, &argv);
batal=MPI_Abort(comm, errorcode);
return 0;
}
Pengaktifan proses MPI portabel:

Pada command prompt, ketiklah perintah berikut:

Mpiexec –n banyaknya_prosesor nama_program

Menggunakan perintah tersebut, jalankan semua program di atas dan di bawah dalam command
prompt, kemudian amati apa yang terjadi.

D.2 Pengatur waktu dan sinkronisasi:

1 2
#include <iostream> #include <iostream>
#include <mpi.h> #include <mpi.h>
using namespace std; using namespace std;
int main() int main()
{ {

20
 double start, end; double resolusi;
int argc, awal; int argc, awal;
char **argv; char **argv;
awal=MPI_Init(&argc, &argv); awal=MPI_Init(&argc, &argv);
start=MPI_Wtime(); resolusi=MPI_Wtick();
cout << "Hello, World" << cout << "Resolusi MPI tunggal
endl; adalah " << resolusi << endl;
end=MPI_Wtime(); return 0;
cout << "Waktu eksekusi = " }
<< end-start << endl;
return 0;
}

D.3 Informasi implementasi:

1 2
#include <iostream> #include <iostream>
#include <mpi.h> #include <mpi.h>
using namespace std; using namespace std;
int main() int main()
{ {
int version, subversion, char
versi; name[MPI_MAX_PROCESSOR_NAME], **argv;
versi=MPI_Get_version(&vers int resultlen, prosesor, argc,
ion, &subversion); awal;
cout << "MPI versi " << awal=MPI_Init(&argc, &argv);
version << "," << subversion << prosesor=MPI_Get_processor_name(
endl; name, &resultlen);
return 0; cout << "Hello, World. Saya " <<
} name << " dengan panjang karakter " <<
resultlen << endl;
return 0;
}

D.4 Alokasi memori:

1 2
#include <mpi.h> #include <mpi.h>
int main() int main()
{ {
int *base, memory, argc, int *base, memori, memory,
awal; argc, awal;
char **argv; char **argv;
MPI_Aint MPI_Aint
size=100*sizeof(int); size=100*sizeof(int);
MPI_Info info=MPI_INFO_NULL; MPI_Info info=MPI_INFO_NULL;
awal=MPI_Init(&argc, &argv); awal=MPI_Init(&argc, &argv);
memory=MPI_Alloc_mem(size, memory=MPI_Alloc_mem(size,
info, &base); info, &base);
return 0; memori=MPI_Free_mem(&base);
} return 0;
}

21
D.4 Penanganan error [1]:
1
#include <mpi.h>
#include <stdio.h>
int total_calls = 0;
MPI_Comm mycomm;
void handle_error(MPI_Comm *comm, int *err, ...)
{
printf("call handle_error\r\n");
if (*err == MPI_ERR_OTHER)
{
printf("Unexpected error code\n");
}
if (*comm != mycomm)
{
printf("Unexpected communicator\n");
}
total_calls++;
return;
}
int main(int argc, char *argv [])
{
MPI_Comm comm;
MPI_Errhandler comm_err;
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
mycomm = comm;
MPI_Comm_create_errhandler(handle_error, &comm_err);
MPI_Comm_set_errhandler(comm, comm_err);
MPI_Comm_call_errhandler(comm, MPI_ERR_OTHER);
MPI_Errhandler_free(&comm_err);
if (total_calls == 0)
{
printf("handle_error tidak dipanggil\r\n");
}
MPI_Finalize();
return 0;
}

2
#include <mpi.h>
#include <stdio.h>
static int total_calls = 0;
static MPI_Win mywin;
static int expected_err_class = MPI_ERR_OTHER;
void error_handle_win( MPI_Win *win, int *err, ... )
{
int errclass;
printf("Fungsi error_handle_win dipanggil\r\n");
MPI_Error_class( *err, &errclass );
if (errclass != expected_err_class)
{
printf( "Unexpected error code (class = %d)\r\n", errclass );
}
if (*win != mywin)
{
printf( "Unexpected window (got %x expected %x)\r\n", (int)*win,
(int)mywin );
}
total_calls++;

22
 return;
}
int main( int argc, char *argv[] )
{
int err;
int buf[2];
MPI_Win win;
MPI_Comm comm;
MPI_Errhandler newerr, olderr;
MPI_Init( &argc, &argv );
comm = MPI_COMM_WORLD;
MPI_Win_create_errhandler( error_handle_win, &newerr );
MPI_Win_create( buf, 2*sizeof(int), sizeof(int),
MPI_INFO_NULL, comm, &win );
mywin = win;
MPI_Win_get_errhandler( win, &olderr );
if (olderr == MPI_ERRORS_ARE_FATAL)
{
printf( "Error yang terjadi fatal\r\n" );
}
MPI_Win_set_errhandler( win, newerr );
expected_err_class = MPI_ERR_RANK;
err = MPI_Put( buf, 1, MPI_INT, -5, 0, 1, MPI_INT, win );
if (total_calls != 1)
{
printf( "Error handle newerr tidak dipanggil\r\n" );
total_calls = 1;
}
expected_err_class = MPI_ERR_OTHER;
MPI_Win_call_errhandler( win, MPI_ERR_OTHER );
if (total_calls != 2)
{
printf( "Error handle newerr tidak dipanggil (2)\r\n" );
}
MPI_Win_free( &win );
MPI_Errhandler_free( &newerr );
MPI_Finalize();
return 0;
}

3
#include <mpi.h>
#include <stdio.h>
#include <string.h>
static int ncalls = 0;
void error_handle( MPI_File *fh, int *code, ... )
{
printf("Fungsi error_handle dipanggil");
ncalls ++;
*code = MPI_SUCCESS;
}
int main( int argc, char *argv[] )
{
MPI_File fh;
MPI_Errhandler eh;
char filename[10];
int rc;
MPI_Init( &argc, &argv );
strncpy(filename, "test_file.dat", sizeof(filename));
rc = MPI_File_open( MPI_COMM_WORLD, filename, MPI_MODE_RDWR,
MPI_INFO_NULL, &fh);

23
 if (!rc)
{
printf("Error ketika membuka file tanpa informasi\r\n");
}
MPI_File_create_errhandler(error_handle, &eh);
MPI_File_set_errhandler(MPI_FILE_NULL, eh);
rc = MPI_File_open(MPI_COMM_WORLD, filename, MPI_MODE_RDWR,
MPI_INFO_NULL, &fh);
if (rc)
{
printf( "Balikan error ketika buka file \r\n");
}
if (ncalls != 1)
{
printf( "Fungsi error_handle tidak dipanggil\r\n" );
}
MPI_Finalize();
return 0;
}

D.5 Kode dan kelas error:

1 2
#include <iostream> #include <iostream>
#include <mpi.h> #include <mpi.h>
using namespace std; using namespace std;
int main() int main()
{ {
int errorcode, resultlen, int errorcode, errorclass,
error, argc, awal; error, argc, awal;
char char **argv;
string[MPI_MAX_ERROR_STRING], awal=MPI_Init(&argc, &argv);
**argv; for (errorcode=0;
awal=MPI_Init(&argc, &argv); errorcode<=60; errorcode++)
for (errorcode=0; {error=MPI_Error_class(errorc
errorcode<=53; errorcode++) ode, &errorclass);
{error=MPI_Error_string(errorc cout << "Error " << errorcode
ode, string, &resultlen); << ": " << errorclass << endl;}
cout << "Error " << errorcode return 0;
<< ": " << string << ", dengan }
panjang karakter " << resultlen <<
endl;}
return 0;
}

D.6 Kelas error, kode error, dan pengendali error:

1
#include "mpi.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NCLASSES 32
#define NCODES 5
int main( int argc, char *argv[] )
{
int errs = 0;
char string[MPI_MAX_ERROR_STRING], outstring[MPI_MAX_ERROR_STRING];
int newclass[NCLASSES], newcode[NCLASSES][NCODES];

24
 int i, j, slen, outclass;
MPI_Init( &argc, &argv );
for (i=0; i<NCLASSES; i++) {
MPI_Add_error_class( &newclass[i] );
for (j=0; j<NCODES; j++) {
MPI_Add_error_code( newclass[i], &newcode[i][j] );
sprintf( string, "code for class %d code %d\n", i, j );
MPI_Add_error_string( newcode[i][j], string );
}
}
for (i=0; i<NCLASSES; i++) {
MPI_Error_class( newclass[i], &outclass );
if (outclass != newclass[i]) {
errs++;
printf( "Error class %d is not a valid error code %x %x\n", i,
outclass, newclass[i]);fflush(stdout);
}
for (j=0; j<NCODES; j++) {
MPI_Error_class( newcode[i][j], &outclass );
if (outclass != newclass[i]) {
errs++;
printf( "Class of code for %d is not correct %x %x\n", j,
outclass, newclass[i] );fflush(stdout);
}
MPI_Error_string( newcode[i][j], outstring, &slen );
sprintf( string, "code for class %d code %d\n", i, j );
if (strcmp( outstring, string )) {
errs++;
printf( "Error string is :%s: but should be :%s:\n",
outstring, string );fflush(stdout);
}
}
}
MPI_Finalize();
return 0;
}

Referensi:

[1] Kurniawan, A., Pemrograman Paralel dengan MPI dan C, 2010, Yogyakarta: Penerbit Andi.

25