00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <mpi.h>
00024
00025 #ifdef __cplusplus
00026 extern "C"
00027 #endif
00028 int MPI_Allgather(
00029 void * sendbuf,
00030 int sendcount,
00031 MPI_Datatype sendtype,
00032 void * recvbuf,
00033 int recvcount,
00034 MPI_Datatype recvtype,
00035 MPI_Comm comm )
00036 {
00037 int returnVal;
00038
00039
00040 returnVal = PMPI_Allgather( sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm );
00041
00042
00043 return returnVal;
00044 }
00045
00046 #ifdef __cplusplus
00047 extern "C"
00048 #endif
00049 int MPI_Allgatherv(
00050 void * sendbuf,
00051 int sendcount,
00052 MPI_Datatype sendtype,
00053 void * recvbuf,
00054 int * recvcounts,
00055 int * displs,
00056 MPI_Datatype recvtype,
00057 MPI_Comm comm )
00058 {
00059 int returnVal;
00060
00061
00062 returnVal = PMPI_Allgatherv( sendbuf, sendcount, sendtype, recvbuf, recvcounts, displs, recvtype, comm );
00063
00064
00065 return returnVal;
00066 }
00067
00068 #ifdef __cplusplus
00069 extern "C"
00070 #endif
00071 int MPI_Allreduce(
00072 void * sendbuf,
00073 void * recvbuf,
00074 int count,
00075 MPI_Datatype datatype,
00076 MPI_Op op,
00077 MPI_Comm comm )
00078 {
00079 int returnVal;
00080
00081
00082 returnVal = PMPI_Allreduce( sendbuf, recvbuf, count, datatype, op, comm );
00083
00084
00085 return returnVal;
00086 }
00087
00088 #ifdef __cplusplus
00089 extern "C"
00090 #endif
00091 int MPI_Alltoall(
00092 void * sendbuf,
00093 int sendcount,
00094 MPI_Datatype sendtype,
00095 void * recvbuf,
00096 int recvcnt,
00097 MPI_Datatype recvtype,
00098 MPI_Comm comm )
00099 {
00100 int returnVal;
00101
00102
00103 returnVal = PMPI_Alltoall( sendbuf, sendcount, sendtype, recvbuf, recvcnt, recvtype, comm );
00104
00105
00106 return returnVal;
00107 }
00108
00109 #ifdef __cplusplus
00110 extern "C"
00111 #endif
00112 int MPI_Alltoallv(
00113 void * sendbuf,
00114 int * sendcnts,
00115 int * sdispls,
00116 MPI_Datatype sendtype,
00117 void * recvbuf,
00118 int * recvcnts,
00119 int * rdispls,
00120 MPI_Datatype recvtype,
00121 MPI_Comm comm )
00122 {
00123 int returnVal;
00124
00125
00126 returnVal = PMPI_Alltoallv( sendbuf, sendcnts, sdispls, sendtype, recvbuf, recvcnts, rdispls, recvtype, comm );
00127
00128
00129 return returnVal;
00130 }
00131
00132 #ifdef __cplusplus
00133 extern "C"
00134 #endif
00135 int MPI_Barrier(
00136 MPI_Comm comm )
00137 {
00138 int returnVal;
00139
00140
00141 returnVal = PMPI_Barrier( comm );
00142
00143
00144 return returnVal;
00145 }
00146
00147 #ifdef __cplusplus
00148 extern "C"
00149 #endif
00150 int MPI_Bcast(
00151 void * buffer,
00152 int count,
00153 MPI_Datatype datatype,
00154 int root,
00155 MPI_Comm comm )
00156 {
00157 int returnVal;
00158
00159
00160 returnVal = PMPI_Bcast( buffer, count, datatype, root, comm );
00161
00162
00163 return returnVal;
00164 }
00165
00166 #ifdef __cplusplus
00167 extern "C"
00168 #endif
00169 int MPI_Gather(
00170 void * sendbuf,
00171 int sendcnt,
00172 MPI_Datatype sendtype,
00173 void * recvbuf,
00174 int recvcount,
00175 MPI_Datatype recvtype,
00176 int root,
00177 MPI_Comm comm )
00178 {
00179 int returnVal;
00180
00181
00182 returnVal = PMPI_Gather( sendbuf, sendcnt, sendtype, recvbuf, recvcount, recvtype, root, comm );
00183
00184
00185 return returnVal;
00186 }
00187
00188 #ifdef __cplusplus
00189 extern "C"
00190 #endif
00191 int MPI_Gatherv(
00192 void * sendbuf,
00193 int sendcnt,
00194 MPI_Datatype sendtype,
00195 void * recvbuf,
00196 int * recvcnts,
00197 int * displs,
00198 MPI_Datatype recvtype,
00199 int root,
00200 MPI_Comm comm )
00201 {
00202 int returnVal;
00203
00204
00205 returnVal = PMPI_Gatherv( sendbuf, sendcnt, sendtype, recvbuf, recvcnts, displs, recvtype, root, comm );
00206
00207
00208 return returnVal;
00209 }
00210
00211 #ifdef __cplusplus
00212 extern "C"
00213 #endif
00214 int MPI_Op_create(
00215 MPI_User_function * function,
00216 int commute,
00217 MPI_Op * op )
00218 {
00219 int returnVal;
00220
00221
00222 returnVal = PMPI_Op_create( function, commute, op );
00223
00224
00225 return returnVal;
00226 }
00227
00228 #ifdef __cplusplus
00229 extern "C"
00230 #endif
00231 int MPI_Op_free(
00232 MPI_Op * op )
00233 {
00234 int returnVal;
00235
00236
00237 returnVal = PMPI_Op_free( op );
00238
00239
00240 return returnVal;
00241 }
00242
00243 #ifdef __cplusplus
00244 extern "C"
00245 #endif
00246 int MPI_Reduce_scatter(
00247 void * sendbuf,
00248 void * recvbuf,
00249 int * recvcnts,
00250 MPI_Datatype datatype,
00251 MPI_Op op,
00252 MPI_Comm comm )
00253 {
00254 int returnVal;
00255
00256
00257 returnVal = PMPI_Reduce_scatter( sendbuf, recvbuf, recvcnts, datatype, op, comm );
00258
00259
00260 return returnVal;
00261 }
00262
00263 #ifdef __cplusplus
00264 extern "C"
00265 #endif
00266 int MPI_Reduce(
00267 void * sendbuf,
00268 void * recvbuf,
00269 int count,
00270 MPI_Datatype datatype,
00271 MPI_Op op,
00272 int root,
00273 MPI_Comm comm )
00274 {
00275 int returnVal;
00276
00277
00278 returnVal = PMPI_Reduce( sendbuf, recvbuf, count, datatype, op, root, comm );
00279
00280
00281 return returnVal;
00282 }
00283
00284 #ifdef __cplusplus
00285 extern "C"
00286 #endif
00287 int MPI_Scan(
00288 void * sendbuf,
00289 void * recvbuf,
00290 int count,
00291 MPI_Datatype datatype,
00292 MPI_Op op,
00293 MPI_Comm comm )
00294 {
00295 int returnVal;
00296
00297
00298 returnVal = PMPI_Scan( sendbuf, recvbuf, count, datatype, op, comm );
00299
00300
00301 return returnVal;
00302 }
00303
00304 #ifdef __cplusplus
00305 extern "C"
00306 #endif
00307 int MPI_Scatter(
00308 void * sendbuf,
00309 int sendcnt,
00310 MPI_Datatype sendtype,
00311 void * recvbuf,
00312 int recvcnt,
00313 MPI_Datatype recvtype,
00314 int root,
00315 MPI_Comm comm )
00316 {
00317 int returnVal;
00318
00319
00320 returnVal = PMPI_Scatter( sendbuf, sendcnt, sendtype, recvbuf, recvcnt, recvtype, root, comm );
00321
00322
00323 return returnVal;
00324 }
00325
00326 #ifdef __cplusplus
00327 extern "C"
00328 #endif
00329 int MPI_Scatterv(
00330 void * sendbuf,
00331 int * sendcnts,
00332 int * displs,
00333 MPI_Datatype sendtype,
00334 void * recvbuf,
00335 int recvcnt,
00336 MPI_Datatype recvtype,
00337 int root,
00338 MPI_Comm comm )
00339 {
00340 int returnVal;
00341
00342
00343 returnVal = PMPI_Scatterv( sendbuf, sendcnts, displs, sendtype, recvbuf, recvcnt, recvtype, root, comm );
00344
00345
00346 return returnVal;
00347 }
00348
00349 #ifdef __cplusplus
00350 extern "C"
00351 #endif
00352 int MPI_Attr_delete(
00353 MPI_Comm comm,
00354 int keyval )
00355 {
00356 int returnVal;
00357
00358
00359 returnVal = PMPI_Attr_delete( comm, keyval );
00360
00361
00362 return returnVal;
00363 }
00364
00365 #ifdef __cplusplus
00366 extern "C"
00367 #endif
00368 int MPI_Attr_get(
00369 MPI_Comm comm,
00370 int keyval,
00371 void * attr_value,
00372 int * flag )
00373 {
00374 int returnVal;
00375
00376
00377 returnVal = PMPI_Attr_get( comm, keyval, attr_value, flag );
00378
00379
00380 return returnVal;
00381 }
00382
00383 #ifdef __cplusplus
00384 extern "C"
00385 #endif
00386 int MPI_Attr_put(
00387 MPI_Comm comm,
00388 int keyval,
00389 void * attr_value )
00390 {
00391 int returnVal;
00392
00393
00394 returnVal = PMPI_Attr_put( comm, keyval, attr_value );
00395
00396
00397 return returnVal;
00398 }
00399
00400 #ifdef __cplusplus
00401 extern "C"
00402 #endif
00403 int MPI_Comm_compare(
00404 MPI_Comm comm1,
00405 MPI_Comm comm2,
00406 int * result )
00407 {
00408 int returnVal;
00409
00410
00411 returnVal = PMPI_Comm_compare( comm1, comm2, result );
00412
00413
00414 return returnVal;
00415 }
00416
00417 #ifdef __cplusplus
00418 extern "C"
00419 #endif
00420 int MPI_Comm_create(
00421 MPI_Comm comm,
00422 MPI_Group group,
00423 MPI_Comm * comm_out )
00424 {
00425 int returnVal;
00426
00427
00428 returnVal = PMPI_Comm_create( comm, group, comm_out );
00429
00430
00431 return returnVal;
00432 }
00433
00434 #ifdef __cplusplus
00435 extern "C"
00436 #endif
00437 int MPI_Comm_dup(
00438 MPI_Comm comm,
00439 MPI_Comm * comm_out )
00440 {
00441 int returnVal;
00442
00443
00444 returnVal = PMPI_Comm_dup( comm, comm_out );
00445
00446
00447 return returnVal;
00448 }
00449
00450 #ifdef __cplusplus
00451 extern "C"
00452 #endif
00453 int MPI_Comm_free(
00454 MPI_Comm * comm )
00455 {
00456 int returnVal;
00457
00458
00459 returnVal = PMPI_Comm_free( comm );
00460
00461
00462 return returnVal;
00463 }
00464
00465 #ifdef __cplusplus
00466 extern "C"
00467 #endif
00468 int MPI_Comm_group(
00469 MPI_Comm comm,
00470 MPI_Group * group )
00471 {
00472 int returnVal;
00473
00474
00475 returnVal = PMPI_Comm_group( comm, group );
00476
00477
00478 return returnVal;
00479 }
00480
00481 #ifdef __cplusplus
00482 extern "C"
00483 #endif
00484 int MPI_Comm_rank(
00485 MPI_Comm comm,
00486 int * rank )
00487 {
00488 int returnVal;
00489
00490
00491 returnVal = PMPI_Comm_rank( comm, rank );
00492
00493
00494 return returnVal;
00495 }
00496
00497 #ifdef __cplusplus
00498 extern "C"
00499 #endif
00500 int MPI_Comm_remote_group(
00501 MPI_Comm comm,
00502 MPI_Group * group )
00503 {
00504 int returnVal;
00505
00506
00507 returnVal = PMPI_Comm_remote_group( comm, group );
00508
00509
00510 return returnVal;
00511 }
00512
00513 #ifdef __cplusplus
00514 extern "C"
00515 #endif
00516 int MPI_Comm_remote_size(
00517 MPI_Comm comm,
00518 int * size )
00519 {
00520 int returnVal;
00521
00522
00523 returnVal = PMPI_Comm_remote_size( comm, size );
00524
00525
00526 return returnVal;
00527 }
00528
00529 #ifdef __cplusplus
00530 extern "C"
00531 #endif
00532 int MPI_Comm_size(
00533 MPI_Comm comm,
00534 int * size )
00535 {
00536 int returnVal;
00537
00538
00539
00540 MPI_Comm kluge;
00541 returnVal = PMPI_Comm_size( kluge, size );
00542
00543
00544 return returnVal;
00545 }
00546
00547 #ifdef __cplusplus
00548 extern "C"
00549 #endif
00550 int MPI_Comm_split(
00551 MPI_Comm comm,
00552 int color,
00553 int key,
00554 MPI_Comm * comm_out )
00555 {
00556 int returnVal;
00557
00558
00559 returnVal = PMPI_Comm_split( comm, color, key, comm_out );
00560
00561
00562 return returnVal;
00563 }
00564
00565 #ifdef __cplusplus
00566 extern "C"
00567 #endif
00568 int MPI_Comm_test_inter(
00569 MPI_Comm comm,
00570 int * flag )
00571 {
00572 int returnVal;
00573
00574
00575 returnVal = PMPI_Comm_test_inter( comm, flag );
00576
00577
00578 return returnVal;
00579 }
00580
00581 #ifdef __cplusplus
00582 extern "C"
00583 #endif
00584 int MPI_Group_compare(
00585 MPI_Group group1,
00586 MPI_Group group2,
00587 int * result )
00588 {
00589 int returnVal;
00590
00591
00592 returnVal = PMPI_Group_compare( group1, group2, result );
00593
00594
00595 return returnVal;
00596 }
00597
00598 #ifdef __cplusplus
00599 extern "C"
00600 #endif
00601 int MPI_Group_difference(
00602 MPI_Group group1,
00603 MPI_Group group2,
00604 MPI_Group * group_out )
00605 {
00606 int returnVal;
00607
00608
00609 returnVal = PMPI_Group_difference( group1, group2, group_out );
00610
00611
00612 return returnVal;
00613 }
00614
00615 #ifdef __cplusplus
00616 extern "C"
00617 #endif
00618 int MPI_Group_excl(
00619 MPI_Group group,
00620 int n,
00621 int * ranks,
00622 MPI_Group * newgroup )
00623 {
00624 int returnVal;
00625
00626
00627 returnVal = PMPI_Group_excl( group, n, ranks, newgroup );
00628
00629
00630 return returnVal;
00631 }
00632
00633 #ifdef __cplusplus
00634 extern "C"
00635 #endif
00636 int MPI_Group_free(
00637 MPI_Group * group )
00638 {
00639 int returnVal;
00640
00641
00642 returnVal = PMPI_Group_free( group );
00643
00644
00645 return returnVal;
00646 }
00647
00648 #ifdef __cplusplus
00649 extern "C"
00650 #endif
00651 int MPI_Group_incl(
00652 MPI_Group group,
00653 int n,
00654 int * ranks,
00655 MPI_Group * group_out )
00656 {
00657 int returnVal;
00658
00659
00660 returnVal = PMPI_Group_incl( group, n, ranks, group_out );
00661
00662
00663 return returnVal;
00664 }
00665
00666 #ifdef __cplusplus
00667 extern "C"
00668 #endif
00669 int MPI_Group_intersection(
00670 MPI_Group group1,
00671 MPI_Group group2,
00672 MPI_Group * group_out )
00673 {
00674 int returnVal;
00675
00676
00677 returnVal = PMPI_Group_intersection( group1, group2, group_out );
00678
00679
00680 return returnVal;
00681 }
00682
00683 #ifdef __cplusplus
00684 extern "C"
00685 #endif
00686 int MPI_Group_rank(
00687 MPI_Group group,
00688 int * rank )
00689 {
00690 int returnVal;
00691
00692
00693 returnVal = PMPI_Group_rank( group, rank );
00694
00695
00696 return returnVal;
00697 }
00698
00699 #ifdef __cplusplus
00700 extern "C"
00701 #endif
00702 int MPI_Group_range_excl(
00703 MPI_Group group,
00704 int n,
00705 int ranges[][3],
00706 MPI_Group * newgroup )
00707 {
00708 int returnVal;
00709
00710
00711 returnVal = PMPI_Group_range_excl( group, n, ranges, newgroup );
00712
00713
00714 return returnVal;
00715 }
00716
00717 #ifdef __cplusplus
00718 extern "C"
00719 #endif
00720 int MPI_Group_range_incl(
00721 MPI_Group group,
00722 int n,
00723 int ranges[][3],
00724 MPI_Group * newgroup )
00725 {
00726 int returnVal;
00727
00728
00729 returnVal = PMPI_Group_range_incl( group, n, ranges, newgroup );
00730
00731
00732 return returnVal;
00733 }
00734
00735 #ifdef __cplusplus
00736 extern "C"
00737 #endif
00738 int MPI_Group_size(
00739 MPI_Group group,
00740 int * size )
00741 {
00742 int returnVal;
00743
00744
00745 returnVal = PMPI_Group_size( group, size );
00746
00747
00748 return returnVal;
00749 }
00750
00751 #ifdef __cplusplus
00752 extern "C"
00753 #endif
00754 int MPI_Group_translate_ranks(
00755 MPI_Group group_a,
00756 int n,
00757 int * ranks_a,
00758 MPI_Group group_b,
00759 int * ranks_b )
00760 {
00761 int returnVal;
00762
00763
00764 returnVal = PMPI_Group_translate_ranks( group_a, n, ranks_a, group_b, ranks_b );
00765
00766
00767 return returnVal;
00768 }
00769
00770 #ifdef __cplusplus
00771 extern "C"
00772 #endif
00773 int MPI_Group_union(
00774 MPI_Group group1,
00775 MPI_Group group2,
00776 MPI_Group * group_out )
00777 {
00778 int returnVal;
00779
00780
00781 returnVal = PMPI_Group_union( group1, group2, group_out );
00782
00783
00784 return returnVal;
00785 }
00786
00787 #ifdef __cplusplus
00788 extern "C"
00789 #endif
00790 int MPI_Intercomm_create(
00791 MPI_Comm local_comm,
00792 int local_leader,
00793 MPI_Comm peer_comm,
00794 int remote_leader,
00795 int tag,
00796 MPI_Comm * comm_out )
00797 {
00798 int returnVal;
00799
00800
00801 returnVal = PMPI_Intercomm_create( local_comm, local_leader, peer_comm, remote_leader, tag, comm_out );
00802
00803
00804 return returnVal;
00805 }
00806
00807 #ifdef __cplusplus
00808 extern "C"
00809 #endif
00810 int MPI_Intercomm_merge(
00811 MPI_Comm comm,
00812 int high,
00813 MPI_Comm * comm_out )
00814 {
00815 int returnVal;
00816
00817
00818 returnVal = PMPI_Intercomm_merge( comm, high, comm_out );
00819
00820
00821 return returnVal;
00822 }
00823
00824 #ifdef __cplusplus
00825 extern "C"
00826 #endif
00827 int MPI_Keyval_create(
00828 MPI_Copy_function * copy_fn,
00829 MPI_Delete_function * delete_fn,
00830 int * keyval,
00831 void * extra_state )
00832 {
00833 int returnVal;
00834
00835
00836 returnVal = PMPI_Keyval_create( copy_fn, delete_fn, keyval, extra_state );
00837
00838
00839 return returnVal;
00840 }
00841
00842 #ifdef __cplusplus
00843 extern "C"
00844 #endif
00845 int MPI_Keyval_free(
00846 int * keyval )
00847 {
00848 int returnVal;
00849
00850
00851 returnVal = PMPI_Keyval_free( keyval );
00852
00853
00854 return returnVal;
00855 }
00856
00857 #ifdef __cplusplus
00858 extern "C"
00859 #endif
00860 int MPI_Abort(
00861 MPI_Comm comm,
00862 int errorcode )
00863 {
00864 int returnVal;
00865
00866
00867 returnVal = PMPI_Abort( comm, errorcode );
00868
00869
00870 return returnVal;
00871 }
00872
00873 #ifdef __cplusplus
00874 extern "C"
00875 #endif
00876 int MPI_Error_class(
00877 int errorcode,
00878 int * errorclass )
00879 {
00880 int returnVal;
00881
00882
00883 returnVal = PMPI_Error_class( errorcode, errorclass );
00884
00885
00886 return returnVal;
00887 }
00888
00889 #ifdef __cplusplus
00890 extern "C"
00891 #endif
00892 int MPI_Errhandler_create(
00893 MPI_Handler_function * function,
00894 MPI_Errhandler * errhandler )
00895 {
00896 int returnVal;
00897
00898
00899 returnVal = PMPI_Errhandler_create( function, errhandler );
00900
00901
00902 return returnVal;
00903 }
00904
00905 #ifdef __cplusplus
00906 extern "C"
00907 #endif
00908 int MPI_Errhandler_free(
00909 MPI_Errhandler * errhandler )
00910 {
00911 int returnVal;
00912
00913
00914 returnVal = PMPI_Errhandler_free( errhandler );
00915
00916
00917 return returnVal;
00918 }
00919
00920 #ifdef __cplusplus
00921 extern "C"
00922 #endif
00923 int MPI_Errhandler_get(
00924 MPI_Comm comm,
00925 MPI_Errhandler * errhandler )
00926 {
00927 int returnVal;
00928
00929
00930 returnVal = PMPI_Errhandler_get( comm, errhandler );
00931
00932
00933 return returnVal;
00934 }
00935
00936 #ifdef __cplusplus
00937 extern "C"
00938 #endif
00939 int MPI_Error_string(
00940 int errorcode,
00941 char * string,
00942 int * resultlen )
00943 {
00944 int returnVal;
00945
00946
00947 returnVal = PMPI_Error_string( errorcode, string, resultlen );
00948
00949
00950 return returnVal;
00951 }
00952
00953 #ifdef __cplusplus
00954 extern "C"
00955 #endif
00956 int MPI_Errhandler_set(
00957 MPI_Comm comm,
00958 MPI_Errhandler errhandler )
00959 {
00960 int returnVal;
00961
00962
00963 returnVal = PMPI_Errhandler_set( comm, errhandler );
00964
00965
00966 return returnVal;
00967 }
00968
00969 #ifdef __cplusplus
00970 extern "C"
00971 #endif
00972 int MPI_Finalize( )
00973 {
00974 int returnVal;
00975
00976
00977 returnVal = PMPI_Finalize( );
00978
00979
00980 return returnVal;
00981 }
00982
00983 #ifdef __cplusplus
00984 extern "C"
00985 #endif
00986 int MPI_Get_processor_name(
00987 char * name,
00988 int * resultlen )
00989 {
00990 int returnVal;
00991
00992
00993 returnVal = PMPI_Get_processor_name( name, resultlen );
00994
00995
00996 return returnVal;
00997 }
00998
00999 #ifdef __cplusplus
01000 extern "C"
01001 #endif
01002 int MPI_Init(
01003 int * argc,
01004 char *** argv )
01005 {
01006 int returnVal;
01007
01008
01009 returnVal = PMPI_Init( argc, argv );
01010
01011
01012 return returnVal;
01013 }
01014
01015 #ifdef __cplusplus
01016 extern "C"
01017 #endif
01018 int MPI_Initialized(
01019 int * flag )
01020 {
01021 int returnVal;
01022
01023
01024 returnVal = PMPI_Initialized( flag );
01025
01026
01027 return returnVal;
01028 }
01029
01030 #ifdef __cplusplus
01031 extern "C"
01032 #endif
01033 double MPI_Wtick( )
01034 {
01035 double returnVal;
01036
01037
01038 returnVal = PMPI_Wtick( );
01039
01040
01041 return returnVal;
01042 }
01043
01044 #ifdef __cplusplus
01045 extern "C"
01046 #endif
01047 int MPI_Address(
01048 void * location,
01049 MPI_Aint * address )
01050 {
01051 int returnVal;
01052
01053
01054 returnVal = PMPI_Address( location, address );
01055
01056
01057 return returnVal;
01058 }
01059
01060 #ifdef __cplusplus
01061 extern "C"
01062 #endif
01063 int MPI_Bsend(
01064 void * buf,
01065 int count,
01066 MPI_Datatype datatype,
01067 int dest,
01068 int tag,
01069 MPI_Comm comm )
01070 {
01071 int returnVal;
01072
01073
01074 returnVal = PMPI_Bsend( buf, count, datatype, dest, tag, comm );
01075
01076
01077 return returnVal;
01078 }
01079
01080 #ifdef __cplusplus
01081 extern "C"
01082 #endif
01083 int MPI_Bsend_init(
01084 void * buf,
01085 int count,
01086 MPI_Datatype datatype,
01087 int dest,
01088 int tag,
01089 MPI_Comm comm,
01090 MPI_Request * request )
01091 {
01092 int returnVal;
01093
01094
01095 returnVal = PMPI_Bsend_init( buf, count, datatype, dest, tag, comm, request );
01096
01097
01098 return returnVal;
01099 }
01100
01101 #ifdef __cplusplus
01102 extern "C"
01103 #endif
01104 int MPI_Buffer_attach(
01105 void * buffer,
01106 int size )
01107 {
01108 int returnVal;
01109
01110
01111 returnVal = PMPI_Buffer_attach( buffer, size );
01112
01113
01114 return returnVal;
01115 }
01116
01117 #ifdef __cplusplus
01118 extern "C"
01119 #endif
01120 int MPI_Buffer_detach(
01121 void * buffer,
01122 int * size )
01123 {
01124 int returnVal;
01125
01126
01127 returnVal = PMPI_Buffer_detach( buffer, size );
01128
01129
01130 return returnVal;
01131 }
01132
01133 #ifdef __cplusplus
01134 extern "C"
01135 #endif
01136 int MPI_Cancel(
01137 MPI_Request * request )
01138 {
01139 int returnVal;
01140
01141
01142 returnVal = PMPI_Cancel( request );
01143
01144
01145 return returnVal;
01146 }
01147
01148 #ifdef __cplusplus
01149 extern "C"
01150 #endif
01151 int MPI_Request_free(
01152 MPI_Request * request )
01153 {
01154 int returnVal;
01155
01156
01157 returnVal = PMPI_Request_free( request );
01158
01159
01160 return returnVal;
01161 }
01162
01163 #ifdef __cplusplus
01164 extern "C"
01165 #endif
01166 int MPI_Recv_init(
01167 void * buf,
01168 int count,
01169 MPI_Datatype datatype,
01170 int source,
01171 int tag,
01172 MPI_Comm comm,
01173 MPI_Request * request )
01174 {
01175 int returnVal;
01176
01177
01178 returnVal = PMPI_Recv_init( buf, count, datatype, source, tag, comm, request );
01179
01180
01181 return returnVal;
01182 }
01183
01184 #ifdef __cplusplus
01185 extern "C"
01186 #endif
01187 int MPI_Send_init(
01188 void * buf,
01189 int count,
01190 MPI_Datatype datatype,
01191 int dest,
01192 int tag,
01193 MPI_Comm comm,
01194 MPI_Request * request )
01195 {
01196 int returnVal;
01197
01198
01199 returnVal = PMPI_Send_init( buf, count, datatype, dest, tag, comm, request );
01200
01201
01202 return returnVal;
01203 }
01204
01205 #ifdef __cplusplus
01206 extern "C"
01207 #endif
01208 int MPI_Get_elements(
01209 MPI_Status * status,
01210 MPI_Datatype datatype,
01211 int * elements )
01212 {
01213 int returnVal;
01214
01215
01216 returnVal = PMPI_Get_elements( status, datatype, elements );
01217
01218
01219 return returnVal;
01220 }
01221
01222 #ifdef __cplusplus
01223 extern "C"
01224 #endif
01225 int MPI_Get_count(
01226 MPI_Status * status,
01227 MPI_Datatype datatype,
01228 int * count )
01229 {
01230 int returnVal;
01231
01232
01233 returnVal = PMPI_Get_count( status, datatype, count );
01234
01235
01236 return returnVal;
01237 }
01238
01239 #ifdef __cplusplus
01240 extern "C"
01241 #endif
01242 int MPI_Ibsend(
01243 void * buf,
01244 int count,
01245 MPI_Datatype datatype,
01246 int dest,
01247 int tag,
01248 MPI_Comm comm,
01249 MPI_Request * request )
01250 {
01251 int returnVal;
01252
01253
01254 returnVal = PMPI_Ibsend( buf, count, datatype, dest, tag, comm, request );
01255
01256
01257 return returnVal;
01258 }
01259
01260 #ifdef __cplusplus
01261 extern "C"
01262 #endif
01263 int MPI_Iprobe(
01264 int source,
01265 int tag,
01266 MPI_Comm comm,
01267 int * flag,
01268 MPI_Status * status )
01269 {
01270 int returnVal;
01271
01272
01273 returnVal = PMPI_Iprobe( source, tag, comm, flag, status );
01274
01275
01276 return returnVal;
01277 }
01278
01279 #ifdef __cplusplus
01280 extern "C"
01281 #endif
01282 int MPI_Irecv(
01283 void * buf,
01284 int count,
01285 MPI_Datatype datatype,
01286 int source,
01287 int tag,
01288 MPI_Comm comm,
01289 MPI_Request * request )
01290 {
01291 int returnVal;
01292
01293
01294 returnVal = PMPI_Irecv( buf, count, datatype, source, tag, comm, request );
01295
01296
01297 return returnVal;
01298 }
01299
01300 #ifdef __cplusplus
01301 extern "C"
01302 #endif
01303 int MPI_Irsend(
01304 void * buf,
01305 int count,
01306 MPI_Datatype datatype,
01307 int dest,
01308 int tag,
01309 MPI_Comm comm,
01310 MPI_Request * request )
01311 {
01312 int returnVal;
01313
01314
01315 returnVal = PMPI_Irsend( buf, count, datatype, dest, tag, comm, request );
01316
01317
01318 return returnVal;
01319 }
01320
01321 #ifdef __cplusplus
01322 extern "C"
01323 #endif
01324 int MPI_Isend(
01325 void * buf,
01326 int count,
01327 MPI_Datatype datatype,
01328 int dest,
01329 int tag,
01330 MPI_Comm comm,
01331 MPI_Request * request )
01332 {
01333 int returnVal;
01334
01335
01336 returnVal = PMPI_Isend( buf, count, datatype, dest, tag, comm, request );
01337
01338
01339 return returnVal;
01340 }
01341
01342 #ifdef __cplusplus
01343 extern "C"
01344 #endif
01345 int MPI_Issend(
01346 void * buf,
01347 int count,
01348 MPI_Datatype datatype,
01349 int dest,
01350 int tag,
01351 MPI_Comm comm,
01352 MPI_Request * request )
01353 {
01354 int returnVal;
01355
01356
01357 returnVal = PMPI_Issend( buf, count, datatype, dest, tag, comm, request );
01358
01359
01360 return returnVal;
01361 }
01362
01363 #ifdef __cplusplus
01364 extern "C"
01365 #endif
01366 int MPI_Pack(
01367 void * inbuf,
01368 int incount,
01369 MPI_Datatype type,
01370 void * outbuf,
01371 int outcount,
01372 int * position,
01373 MPI_Comm comm )
01374 {
01375 int returnVal;
01376
01377
01378 returnVal = PMPI_Pack( inbuf, incount, type, outbuf, outcount, position, comm );
01379
01380
01381 return returnVal;
01382 }
01383
01384 #ifdef __cplusplus
01385 extern "C"
01386 #endif
01387 int MPI_Pack_size(
01388 int incount,
01389 MPI_Datatype datatype,
01390 MPI_Comm comm,
01391 int * size )
01392 {
01393 int returnVal;
01394
01395
01396 returnVal = PMPI_Pack_size( incount, datatype, comm, size );
01397
01398
01399 return returnVal;
01400 }
01401
01402 #ifdef __cplusplus
01403 extern "C"
01404 #endif
01405 int MPI_Probe(
01406 int source,
01407 int tag,
01408 MPI_Comm comm,
01409 MPI_Status * status )
01410 {
01411 int returnVal;
01412
01413
01414 returnVal = PMPI_Probe( source, tag, comm, status );
01415
01416
01417 return returnVal;
01418 }
01419
01420 #ifdef __cplusplus
01421 extern "C"
01422 #endif
01423 int MPI_Recv(
01424 void * buf,
01425 int count,
01426 MPI_Datatype datatype,
01427 int source,
01428 int tag,
01429 MPI_Comm comm,
01430 MPI_Status * status )
01431 {
01432 int returnVal;
01433
01434
01435 returnVal = PMPI_Recv( buf, count, datatype, source, tag, comm, status );
01436
01437
01438 return returnVal;
01439 }
01440
01441 #ifdef __cplusplus
01442 extern "C"
01443 #endif
01444 int MPI_Rsend(
01445 void * buf,
01446 int count,
01447 MPI_Datatype datatype,
01448 int dest,
01449 int tag,
01450 MPI_Comm comm )
01451 {
01452 int returnVal;
01453
01454
01455 returnVal = PMPI_Rsend( buf, count, datatype, dest, tag, comm );
01456
01457
01458 return returnVal;
01459 }
01460
01461 #ifdef __cplusplus
01462 extern "C"
01463 #endif
01464 int MPI_Rsend_init(
01465 void * buf,
01466 int count,
01467 MPI_Datatype datatype,
01468 int dest,
01469 int tag,
01470 MPI_Comm comm,
01471 MPI_Request * request )
01472 {
01473 int returnVal;
01474
01475
01476 returnVal = PMPI_Rsend_init( buf, count, datatype, dest, tag, comm, request );
01477
01478
01479 return returnVal;
01480 }
01481
01482 #ifdef __cplusplus
01483 extern "C"
01484 #endif
01485 int MPI_Send(
01486 void * buf,
01487 int count,
01488 MPI_Datatype datatype,
01489 int dest,
01490 int tag,
01491 MPI_Comm comm )
01492 {
01493 int returnVal;
01494
01495
01496 returnVal = PMPI_Send( buf, count, datatype, dest, tag, comm );
01497
01498
01499 return returnVal;
01500 }
01501
01502 #ifdef __cplusplus
01503 extern "C"
01504 #endif
01505 int MPI_Sendrecv(
01506 void * sendbuf,
01507 int sendcount,
01508 MPI_Datatype sendtype,
01509 int dest,
01510 int sendtag,
01511 void * recvbuf,
01512 int recvcount,
01513 MPI_Datatype recvtype,
01514 int source,
01515 int recvtag,
01516 MPI_Comm comm,
01517 MPI_Status * status )
01518 {
01519 int returnVal;
01520
01521
01522 returnVal = PMPI_Sendrecv( sendbuf, sendcount, sendtype, dest, sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status );
01523
01524
01525 return returnVal;
01526 }
01527
01528 #ifdef __cplusplus
01529 extern "C"
01530 #endif
01531 int MPI_Sendrecv_replace(
01532 void * buf,
01533 int count,
01534 MPI_Datatype datatype,
01535 int dest,
01536 int sendtag,
01537 int source,
01538 int recvtag,
01539 MPI_Comm comm,
01540 MPI_Status * status )
01541 {
01542 int returnVal;
01543
01544
01545 returnVal = PMPI_Sendrecv_replace( buf, count, datatype, dest, sendtag, source, recvtag, comm, status );
01546
01547
01548 return returnVal;
01549 }
01550
01551 #ifdef __cplusplus
01552 extern "C"
01553 #endif
01554 int MPI_Ssend(
01555 void * buf,
01556 int count,
01557 MPI_Datatype datatype,
01558 int dest,
01559 int tag,
01560 MPI_Comm comm )
01561 {
01562 int returnVal;
01563
01564
01565 returnVal = PMPI_Ssend( buf, count, datatype, dest, tag, comm );
01566
01567
01568 return returnVal;
01569 }
01570
01571 #ifdef __cplusplus
01572 extern "C"
01573 #endif
01574 int MPI_Ssend_init(
01575 void * buf,
01576 int count,
01577 MPI_Datatype datatype,
01578 int dest,
01579 int tag,
01580 MPI_Comm comm,
01581 MPI_Request * request )
01582 {
01583 int returnVal;
01584
01585
01586 returnVal = PMPI_Ssend_init( buf, count, datatype, dest, tag, comm, request );
01587
01588
01589 return returnVal;
01590 }
01591
01592 #ifdef __cplusplus
01593 extern "C"
01594 #endif
01595 int MPI_Start(
01596 MPI_Request * request )
01597 {
01598 int returnVal;
01599
01600
01601 returnVal = PMPI_Start( request );
01602
01603
01604 return returnVal;
01605 }
01606
01607 #ifdef __cplusplus
01608 extern "C"
01609 #endif
01610 int MPI_Startall(
01611 int count,
01612 MPI_Request * array_of_requests )
01613 {
01614 int returnVal;
01615
01616
01617 returnVal = PMPI_Startall( count, array_of_requests );
01618
01619
01620 return returnVal;
01621 }
01622
01623 #ifdef __cplusplus
01624 extern "C"
01625 #endif
01626 int MPI_Test(
01627 MPI_Request * request,
01628 int * flag,
01629 MPI_Status * status )
01630 {
01631 int returnVal;
01632
01633
01634 returnVal = PMPI_Test( request, flag, status );
01635
01636
01637 return returnVal;
01638 }
01639
01640 #ifdef __cplusplus
01641 extern "C"
01642 #endif
01643 int MPI_Testall(
01644 int count,
01645 MPI_Request * array_of_requests,
01646 int * flag,
01647 MPI_Status * array_of_statuses )
01648 {
01649 int returnVal;
01650
01651
01652 returnVal = PMPI_Testall( count, array_of_requests, flag, array_of_statuses );
01653
01654
01655 return returnVal;
01656 }
01657
01658 #ifdef __cplusplus
01659 extern "C"
01660 #endif
01661 int MPI_Testany(
01662 int count,
01663 MPI_Request * array_of_requests,
01664 int * index,
01665 int * flag,
01666 MPI_Status * status )
01667 {
01668 int returnVal;
01669
01670
01671 returnVal = PMPI_Testany( count, array_of_requests, index, flag, status );
01672
01673
01674 return returnVal;
01675 }
01676
01677 #ifdef __cplusplus
01678 extern "C"
01679 #endif
01680 int MPI_Test_cancelled(
01681 MPI_Status * status,
01682 int * flag )
01683 {
01684 int returnVal;
01685
01686
01687 returnVal = PMPI_Test_cancelled( status, flag );
01688
01689
01690 return returnVal;
01691 }
01692
01693 #ifdef __cplusplus
01694 extern "C"
01695 #endif
01696 int MPI_Testsome(
01697 int incount,
01698 MPI_Request * array_of_requests,
01699 int * outcount,
01700 int * array_of_indices,
01701 MPI_Status * array_of_statuses )
01702 {
01703 int returnVal;
01704
01705
01706 returnVal = PMPI_Testsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );
01707
01708
01709 return returnVal;
01710 }
01711
01712 #ifdef __cplusplus
01713 extern "C"
01714 #endif
01715 int MPI_Type_commit(
01716 MPI_Datatype * datatype )
01717 {
01718 int returnVal;
01719
01720
01721 returnVal = PMPI_Type_commit( datatype );
01722
01723
01724 return returnVal;
01725 }
01726
01727 #ifdef __cplusplus
01728 extern "C"
01729 #endif
01730 int MPI_Type_contiguous(
01731 int count,
01732 MPI_Datatype old_type,
01733 MPI_Datatype * newtype )
01734 {
01735 int returnVal;
01736
01737
01738 returnVal = PMPI_Type_contiguous( count, old_type, newtype );
01739
01740
01741 return returnVal;
01742 }
01743
01744 #ifdef __cplusplus
01745 extern "C"
01746 #endif
01747 int MPI_Type_extent(
01748 MPI_Datatype datatype,
01749 MPI_Aint * extent )
01750 {
01751 int returnVal;
01752
01753
01754 returnVal = PMPI_Type_extent( datatype, extent );
01755
01756
01757 return returnVal;
01758 }
01759
01760 #ifdef __cplusplus
01761 extern "C"
01762 #endif
01763 int MPI_Type_free(
01764 MPI_Datatype * datatype )
01765 {
01766 int returnVal;
01767
01768
01769 returnVal = PMPI_Type_free( datatype );
01770
01771
01772 return returnVal;
01773 }
01774
01775 #ifdef __cplusplus
01776 extern "C"
01777 #endif
01778 int MPI_Type_hindexed(
01779 int count,
01780 int * blocklens,
01781 MPI_Aint * indices,
01782 MPI_Datatype old_type,
01783 MPI_Datatype * newtype )
01784 {
01785 int returnVal;
01786
01787
01788 returnVal = PMPI_Type_hindexed( count, blocklens, indices, old_type, newtype );
01789
01790
01791 return returnVal;
01792 }
01793
01794 #ifdef __cplusplus
01795 extern "C"
01796 #endif
01797 int MPI_Type_hvector(
01798 int count,
01799 int blocklen,
01800 MPI_Aint stride,
01801 MPI_Datatype old_type,
01802 MPI_Datatype * newtype )
01803 {
01804 int returnVal;
01805
01806
01807 returnVal = PMPI_Type_hvector( count, blocklen, stride, old_type, newtype );
01808
01809
01810 return returnVal;
01811 }
01812
01813 #ifdef __cplusplus
01814 extern "C"
01815 #endif
01816 int MPI_Type_indexed(
01817 int count,
01818 int * blocklens,
01819 int * indices,
01820 MPI_Datatype old_type,
01821 MPI_Datatype * newtype )
01822 {
01823 int returnVal;
01824
01825
01826 returnVal = PMPI_Type_indexed( count, blocklens, indices, old_type, newtype );
01827
01828
01829 return returnVal;
01830 }
01831
01832 #ifdef __cplusplus
01833 extern "C"
01834 #endif
01835 int MPI_Type_lb(
01836 MPI_Datatype datatype,
01837 MPI_Aint * displacement )
01838 {
01839 int returnVal;
01840
01841
01842 returnVal = PMPI_Type_lb( datatype, displacement );
01843
01844
01845 return returnVal;
01846 }
01847
01848 #ifdef __cplusplus
01849 extern "C"
01850 #endif
01851 int MPI_Type_size(
01852 MPI_Datatype datatype,
01853 int * size )
01854 {
01855 int returnVal;
01856
01857
01858 returnVal = PMPI_Type_size( datatype, size );
01859
01860
01861 return returnVal;
01862 }
01863
01864 #ifdef __cplusplus
01865 extern "C"
01866 #endif
01867 int MPI_Type_struct(
01868 int count,
01869 int * blocklens,
01870 MPI_Aint * indices,
01871 MPI_Datatype * old_types,
01872 MPI_Datatype * newtype )
01873 {
01874 int returnVal;
01875
01876
01877 returnVal = PMPI_Type_struct( count, blocklens, indices, old_types, newtype );
01878
01879
01880 return returnVal;
01881 }
01882
01883 #ifdef __cplusplus
01884 extern "C"
01885 #endif
01886 int MPI_Type_ub(
01887 MPI_Datatype datatype,
01888 MPI_Aint * displacement )
01889 {
01890 int returnVal;
01891
01892
01893 returnVal = PMPI_Type_ub( datatype, displacement );
01894
01895
01896 return returnVal;
01897 }
01898
01899 #ifdef __cplusplus
01900 extern "C"
01901 #endif
01902 int MPI_Type_vector(
01903 int count,
01904 int blocklen,
01905 int stride,
01906 MPI_Datatype old_type,
01907 MPI_Datatype * newtype )
01908 {
01909 int returnVal;
01910
01911
01912 returnVal = PMPI_Type_vector( count, blocklen, stride, old_type, newtype );
01913
01914
01915 return returnVal;
01916 }
01917
01918 #ifdef __cplusplus
01919 extern "C"
01920 #endif
01921 int MPI_Unpack(
01922 void * inbuf,
01923 int insize,
01924 int * position,
01925 void * outbuf,
01926 int outcount,
01927 MPI_Datatype type,
01928 MPI_Comm comm )
01929 {
01930 int returnVal;
01931
01932
01933 returnVal = PMPI_Unpack( inbuf, insize, position, outbuf, outcount, type, comm );
01934
01935
01936 return returnVal;
01937 }
01938
01939 #ifdef __cplusplus
01940 extern "C"
01941 #endif
01942 int MPI_Wait(
01943 MPI_Request * request,
01944 MPI_Status * status )
01945 {
01946 int returnVal;
01947
01948
01949 returnVal = PMPI_Wait( request, status );
01950
01951
01952 return returnVal;
01953 }
01954
01955 #ifdef __cplusplus
01956 extern "C"
01957 #endif
01958 int MPI_Waitall(
01959 int count,
01960 MPI_Request * array_of_requests,
01961 MPI_Status * array_of_statuses )
01962 {
01963 int returnVal;
01964
01965
01966 returnVal = PMPI_Waitall( count, array_of_requests, array_of_statuses );
01967
01968
01969 return returnVal;
01970 }
01971
01972 #ifdef __cplusplus
01973 extern "C"
01974 #endif
01975 int MPI_Waitany(
01976 int count,
01977 MPI_Request * array_of_requests,
01978 int * index,
01979 MPI_Status * status )
01980 {
01981 int returnVal;
01982
01983
01984 returnVal = PMPI_Waitany( count, array_of_requests, index, status );
01985
01986
01987 return returnVal;
01988 }
01989
01990 #ifdef __cplusplus
01991 extern "C"
01992 #endif
01993 int MPI_Waitsome(
01994 int incount,
01995 MPI_Request * array_of_requests,
01996 int * outcount,
01997 int * array_of_indices,
01998 MPI_Status * array_of_statuses )
01999 {
02000 int returnVal;
02001
02002
02003 returnVal = PMPI_Waitsome( incount, array_of_requests, outcount, array_of_indices, array_of_statuses );
02004
02005
02006 return returnVal;
02007 }
02008
02009 #ifdef __cplusplus
02010 extern "C"
02011 #endif
02012 int MPI_Cart_coords(
02013 MPI_Comm comm,
02014 int rank,
02015 int maxdims,
02016 int * coords )
02017 {
02018 int returnVal;
02019
02020
02021 returnVal = PMPI_Cart_coords( comm, rank, maxdims, coords );
02022
02023
02024 return returnVal;
02025 }
02026
02027 #ifdef __cplusplus
02028 extern "C"
02029 #endif
02030 int MPI_Cart_create(
02031 MPI_Comm comm_old,
02032 int ndims,
02033 int * dims,
02034 int * periods,
02035 int reorder,
02036 MPI_Comm * comm_cart )
02037 {
02038 int returnVal;
02039
02040
02041 returnVal = PMPI_Cart_create( comm_old, ndims, dims, periods, reorder, comm_cart );
02042
02043
02044 return returnVal;
02045 }
02046
02047 #ifdef __cplusplus
02048 extern "C"
02049 #endif
02050 int MPI_Cart_get(
02051 MPI_Comm comm,
02052 int maxdims,
02053 int * dims,
02054 int * periods,
02055 int * coords )
02056 {
02057 int returnVal;
02058
02059
02060 returnVal = PMPI_Cart_get( comm, maxdims, dims, periods, coords );
02061
02062
02063 return returnVal;
02064 }
02065
02066 #ifdef __cplusplus
02067 extern "C"
02068 #endif
02069 int MPI_Cart_map(
02070 MPI_Comm comm_old,
02071 int ndims,
02072 int * dims,
02073 int * periods,
02074 int * newrank )
02075 {
02076 int returnVal;
02077
02078
02079 returnVal = PMPI_Cart_map( comm_old, ndims, dims, periods, newrank );
02080
02081
02082 return returnVal;
02083 }
02084
02085 #ifdef __cplusplus
02086 extern "C"
02087 #endif
02088 int MPI_Cart_rank(
02089 MPI_Comm comm,
02090 int * coords,
02091 int * rank )
02092 {
02093 int returnVal;
02094
02095
02096 returnVal = PMPI_Cart_rank( comm, coords, rank );
02097
02098
02099 return returnVal;
02100 }
02101
02102 #ifdef __cplusplus
02103 extern "C"
02104 #endif
02105 int MPI_Cart_shift(
02106 MPI_Comm comm,
02107 int direction,
02108 int displ,
02109 int * source,
02110 int * dest )
02111 {
02112 int returnVal;
02113
02114
02115 returnVal = PMPI_Cart_shift( comm, direction, displ, source, dest );
02116
02117
02118 return returnVal;
02119 }
02120
02121 #ifdef __cplusplus
02122 extern "C"
02123 #endif
02124 int MPI_Cart_sub(
02125 MPI_Comm comm,
02126 int * remain_dims,
02127 MPI_Comm * comm_new )
02128 {
02129 int returnVal;
02130
02131
02132 returnVal = PMPI_Cart_sub( comm, remain_dims, comm_new );
02133
02134
02135 return returnVal;
02136 }
02137
02138 #ifdef __cplusplus
02139 extern "C"
02140 #endif
02141 int MPI_Cartdim_get(
02142 MPI_Comm comm,
02143 int * ndims )
02144 {
02145 int returnVal;
02146
02147
02148 returnVal = PMPI_Cartdim_get( comm, ndims );
02149
02150
02151 return returnVal;
02152 }
02153
02154 #ifdef __cplusplus
02155 extern "C"
02156 #endif
02157 int MPI_Dims_create(
02158 int nnodes,
02159 int ndims,
02160 int * dims )
02161 {
02162 int returnVal;
02163
02164
02165 returnVal = PMPI_Dims_create( nnodes, ndims, dims );
02166
02167
02168 return returnVal;
02169 }
02170
02171 #ifdef __cplusplus
02172 extern "C"
02173 #endif
02174 int MPI_Graph_create(
02175 MPI_Comm comm_old,
02176 int nnodes,
02177 int * index,
02178 int * edges,
02179 int reorder,
02180 MPI_Comm * comm_graph )
02181 {
02182 int returnVal;
02183
02184
02185 returnVal = PMPI_Graph_create( comm_old, nnodes, index, edges, reorder, comm_graph );
02186
02187
02188 return returnVal;
02189 }
02190
02191 #ifdef __cplusplus
02192 extern "C"
02193 #endif
02194 int MPI_Graph_get(
02195 MPI_Comm comm,
02196 int maxindex,
02197 int maxedges,
02198 int * index,
02199 int * edges )
02200 {
02201 int returnVal;
02202
02203
02204 returnVal = PMPI_Graph_get( comm, maxindex, maxedges, index, edges );
02205
02206
02207 return returnVal;
02208 }
02209
02210 #ifdef __cplusplus
02211 extern "C"
02212 #endif
02213 int MPI_Graph_map(
02214 MPI_Comm comm_old,
02215 int nnodes,
02216 int * index,
02217 int * edges,
02218 int * newrank )
02219 {
02220 int returnVal;
02221
02222
02223 returnVal = PMPI_Graph_map( comm_old, nnodes, index, edges, newrank );
02224
02225
02226 return returnVal;
02227 }
02228
02229 #ifdef __cplusplus
02230 extern "C"
02231 #endif
02232 int MPI_Graph_neighbors(
02233 MPI_Comm comm,
02234 int rank,
02235 int maxneighbors,
02236 int * neighbors )
02237 {
02238 int returnVal;
02239
02240
02241 returnVal = PMPI_Graph_neighbors( comm, rank, maxneighbors, neighbors );
02242
02243
02244 return returnVal;
02245 }
02246
02247 #ifdef __cplusplus
02248 extern "C"
02249 #endif
02250 int MPI_Graph_neighbors_count(
02251 MPI_Comm comm,
02252 int rank,
02253 int * nneighbors )
02254 {
02255 int returnVal;
02256
02257
02258 returnVal = PMPI_Graph_neighbors_count( comm, rank, nneighbors );
02259
02260
02261 return returnVal;
02262 }
02263
02264 #ifdef __cplusplus
02265 extern "C"
02266 #endif
02267 int MPI_Graphdims_get(
02268 MPI_Comm comm,
02269 int * nnodes,
02270 int * nedges )
02271 {
02272 int returnVal;
02273
02274
02275 returnVal = PMPI_Graphdims_get( comm, nnodes, nedges );
02276
02277
02278 return returnVal;
02279 }
02280
02281 #ifdef __cplusplus
02282 extern "C"
02283 #endif
02284 int MPI_Topo_test(
02285 MPI_Comm comm,
02286 int * top_type )
02287 {
02288 int returnVal;
02289
02290
02291 returnVal = PMPI_Topo_test( comm, top_type );
02292
02293
02294 return returnVal;
02295 }