Changeset 408629


Ignore:
Timestamp:
06/10/14 14:51:20 (4 weeks ago)
Author:
Antonio J. Pena <apenya@…>
Branches:
master
Children:
5b4bde
Parents:
00f452
git-author:
Wesley Bland <wbland@…> (05/21/14 10:12:16)
git-committer:
Antonio J. Pena <apenya@…> (06/10/14 14:51:20)
Message:

Improve error checking for buffer aliasing

If the user isn't using MPI_IN_PLACE when they should, this check will do a
better job of warning them about it.

See #2049

Signed-off-by: Antonio J. Pena <apenya@…>

Location:
src/mpi/coll
Files:
29 edited

Legend:

Unmodified
Added
Removed
  • src/mpi/coll/allgather.c

    ra18820 r408629  
    933933            if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
    934934 
    935             if (comm_ptr->comm_kind == MPID_INTERCOMM) 
     935            if (comm_ptr->comm_kind == MPID_INTERCOMM) { 
    936936                MPIR_ERRTEST_SENDBUF_INPLACE(sendbuf, sendcount, mpi_errno); 
     937            } else { 
     938                /* catch common aliasing cases */ 
     939                if (sendbuf != MPI_IN_PLACE && sendtype == recvtype && 
     940                        recvcount != 0 && sendcount != 0) { 
     941                    int recvtype_size; 
     942                    MPID_Datatype_get_size_macro(recvtype, recvtype_size); 
     943                    MPIR_ERRTEST_ALIAS_COLL(sendbuf, (char*)recvbuf + comm_ptr->rank*recvcount*recvtype_size, mpi_errno); 
     944                } 
     945            } 
     946 
    937947            if (sendbuf != MPI_IN_PLACE) 
    938948            { 
     
    962972            } 
    963973            MPIR_ERRTEST_USERBUFFER(recvbuf,recvcount,recvtype,mpi_errno); 
    964  
    965             /* catch common aliasing cases */ 
    966             if (sendbuf != MPI_IN_PLACE && sendtype == recvtype && recvcount != 0 && sendcount != 0) 
    967                 MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
    968974        } 
    969975        MPID_END_ERROR_CHECKS; 
  • src/mpi/coll/allgatherv.c

    r8c133e r408629  
    10581058                } 
    10591059                MPIR_ERRTEST_USERBUFFER(sendbuf,sendcount,sendtype,mpi_errno); 
     1060 
     1061                /* catch common aliasing cases */ 
     1062                if (comm_ptr->comm_kind == MPID_INTRACOMM && 
     1063                        sendtype == recvtype && 
     1064                        recvcounts[comm_ptr->rank] != 0 && 
     1065                        sendcount != 0) { 
     1066                    int recvtype_size; 
     1067                    MPID_Datatype_get_size_macro(recvtype, recvtype_size); 
     1068                    MPIR_ERRTEST_ALIAS_COLL(sendbuf, (char*)recvbuf + displs[comm_ptr->rank]*recvtype_size, mpi_errno); 
     1069                } 
    10601070            } 
    10611071 
  • src/mpi/coll/allreduce.c

    r8c133e r408629  
    869869            } 
    870870 
    871             if (comm_ptr->comm_kind == MPID_INTERCOMM) 
     871            if (comm_ptr->comm_kind == MPID_INTERCOMM) { 
    872872                MPIR_ERRTEST_SENDBUF_INPLACE(sendbuf, count, mpi_errno); 
     873            } else { 
     874                if (count != 0 && sendbuf != MPI_IN_PLACE) 
     875                    MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
     876            } 
    873877             
    874878            if (sendbuf != MPI_IN_PLACE)  
     
    886890                    ( * MPIR_OP_HDL_TO_DTYPE_FN(op) )(datatype);  
    887891            } 
    888             if (count != 0) { 
    889                 MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
    890             } 
    891892            if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
    892893        } 
  • src/mpi/coll/alltoall.c

    ra18820 r408629  
    846846                    if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
    847847                } 
     848 
     849                if (comm_ptr->comm_kind == MPID_INTRACOMM && 
     850                        sendbuf != MPI_IN_PLACE && 
     851                        sendcount == recvcount && 
     852                        sendtype == recvtype && 
     853                        sendcount != 0) 
     854                    MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
    848855            } 
    849856 
  • src/mpi/coll/alltoallv.c

    rb9531d r408629  
    470470            if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
    471471 
    472             if (comm_ptr->comm_kind == MPID_INTRACOMM) 
     472            if (comm_ptr->comm_kind == MPID_INTRACOMM) { 
    473473                comm_size = comm_ptr->local_size; 
    474             else 
     474 
     475                if (sendbuf != MPI_IN_PLACE && sendtype == recvtype && sendcounts == recvcounts) 
     476                    MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
     477            } else 
    475478                comm_size = comm_ptr->remote_size; 
    476479 
  • src/mpi/coll/alltoallw.c

    rb9531d r408629  
    472472            } 
    473473 
    474             if (comm_ptr->comm_kind == MPID_INTRACOMM) 
     474            if (comm_ptr->comm_kind == MPID_INTRACOMM) { 
    475475                comm_size = comm_ptr->local_size; 
    476             else 
     476 
     477                if (sendbuf != MPI_IN_PLACE && sendcounts == recvcounts && sendtypes == recvtypes) 
     478                    MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
     479            } else 
    477480                comm_size = comm_ptr->remote_size; 
    478481 
  • src/mpi/coll/exscan.c

    r893492 r408629  
    370370                    ( * MPIR_OP_HDL_TO_DTYPE_FN(op) )(datatype);  
    371371            } 
    372              
    373372            if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
     373 
     374            if (sendbuf != MPI_IN_PLACE) 
     375                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
    374376        } 
    375377        MPID_END_ERROR_CHECKS; 
  • src/mpi/coll/gather.c

    ra18820 r408629  
    825825 
    826826                    /* catch common aliasing cases */ 
    827                     if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && sendcount != 0) 
    828                         MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
     827                    if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && sendcount != 0) { 
     828                        int recvtype_size; 
     829                        MPID_Datatype_get_size_macro(recvtype, recvtype_size); 
     830                        MPIR_ERRTEST_ALIAS_COLL(sendbuf, ((char *)recvbuf) + comm_ptr->rank*recvcount*recvtype_size,mpi_errno); 
     831                    } 
    829832                } 
    830833                else 
  • src/mpi/coll/gatherv.c

    r8c133e r408629  
    356356                        } 
    357357                    } 
     358 
     359                    /* catch common aliasing cases */ 
     360                    if (sendbuf != MPI_IN_PLACE && sendtype == recvtype && recvcounts[comm_ptr->rank] != 0 && sendcount != 0) { 
     361                        int recvtype_size; 
     362                        MPID_Datatype_get_size_macro(recvtype, recvtype_size); 
     363                        MPIR_ERRTEST_ALIAS_COLL(sendbuf, (char*)recvbuf + displs[comm_ptr->rank]*recvtype_size, mpi_errno); 
     364                    } 
    358365                } 
    359366                else 
  • src/mpi/coll/iallgather.c

    ra31d19 r408629  
    711711 
    712712            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
    713             /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
     713 
     714            /* catch common aliasing cases */ 
     715            if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && sendcount != 0) { 
     716                int recvtype_size; 
     717                MPID_Datatype_get_size_macro(recvtype, recvtype_size); 
     718                MPIR_ERRTEST_ALIAS_COLL(sendbuf, (char*)recvbuf + comm_ptr->rank*recvcount*recvtype_size, mpi_errno); 
     719            } 
     720 
     721            /* TODO more checks may be appropriate (counts, in_place, etc) */ 
    714722        } 
    715723        MPID_END_ERROR_CHECKS 
  • src/mpi/coll/iallgatherv.c

    r8ea1dfe r408629  
    797797            if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
    798798 
    799             if (sendbuf != MPI_IN_PLACE && HANDLE_GET_KIND(sendtype) != HANDLE_KIND_BUILTIN) { 
    800                 MPID_Datatype *sendtype_ptr = NULL; 
    801                 MPID_Datatype_get_ptr(sendtype, sendtype_ptr); 
    802                 MPID_Datatype_valid_ptr(sendtype_ptr, mpi_errno); 
    803                 if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
    804                 MPID_Datatype_committed_ptr(sendtype_ptr, mpi_errno); 
    805                 if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
     799            if (sendbuf != MPI_IN_PLACE) { 
     800                if (HANDLE_GET_KIND(sendtype) != HANDLE_KIND_BUILTIN) { 
     801                    MPID_Datatype *sendtype_ptr = NULL; 
     802                    MPID_Datatype_get_ptr(sendtype, sendtype_ptr); 
     803                    MPID_Datatype_valid_ptr(sendtype_ptr, mpi_errno); 
     804                    if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
     805                    MPID_Datatype_committed_ptr(sendtype_ptr, mpi_errno); 
     806                    if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
     807                } 
     808 
     809                /* catch common aliasing cases */ 
     810                if (comm_ptr->comm_kind == MPID_INTRACOMM && 
     811                        sendtype == recvtype && 
     812                        recvcounts[comm_ptr->rank] != 0 && 
     813                        sendcount != 0) { 
     814                    int recvtype_size; 
     815                    MPID_Datatype_get_size_macro(recvtype, recvtype_size); 
     816                    MPIR_ERRTEST_ALIAS_COLL(sendbuf, (char*)recvbuf + displs[comm_ptr->rank]*recvtype_size, mpi_errno); 
     817                } 
    806818            } 
    807819 
  • src/mpi/coll/iallreduce.c

    ra31d19 r408629  
    773773 
    774774            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
     775 
     776            if (comm_ptr->comm_kind == MPID_INTRACOMM && count != 0 && sendbuf != MPI_IN_PLACE) 
     777                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
     778 
    775779            /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
    776780        } 
  • src/mpi/coll/ialltoall.c

    ra31d19 r408629  
    642642 
    643643            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
    644             /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
     644 
     645            if (comm_ptr->comm_kind == MPID_INTRACOMM && 
     646                    sendbuf != MPI_IN_PLACE && 
     647                    sendcount == recvcount && 
     648                    sendtype == recvtype && 
     649                    sendcount != 0) 
     650                MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
     651            /* TODO more checks may be appropriate (counts, in_place, etc) */ 
    645652        } 
    646653        MPID_END_ERROR_CHECKS 
  • src/mpi/coll/ialltoallv.c

    r7d9833 r408629  
    379379 
    380380            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
     381 
     382            if (comm_ptr->comm_kind == MPID_INTRACOMM && 
     383                    sendbuf != MPI_IN_PLACE && 
     384                    sendcounts == recvcounts && 
     385                    sendtype == recvtype) 
     386                MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
    381387            /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
    382388        } 
  • src/mpi/coll/ialltoallw.c

    r7d9833 r408629  
    361361                MPIR_ERRTEST_ARGNULL(sdispls,"sdispls", mpi_errno); 
    362362                MPIR_ERRTEST_ARGNULL(sendtypes,"sendtypes", mpi_errno); 
     363 
     364                if (comm_ptr->comm_kind == MPID_INTRACOMM && 
     365                        sendcounts == recvcounts && 
     366                        sendtypes == recvtypes) 
     367                    MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
    363368            } 
    364369            MPIR_ERRTEST_ARGNULL(recvcounts,"recvcounts", mpi_errno); 
     
    369374            } 
    370375            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
    371             /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
     376            /* TODO more checks may be appropriate (counts, in_place, etc) */ 
    372377        } 
    373378        MPID_END_ERROR_CHECKS 
  • src/mpi/coll/iexscan.c

    r893492 r408629  
    306306 
    307307            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
    308             /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
     308 
     309            if (sendbuf != MPI_IN_PLACE) 
     310                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
     311            /* TODO more checks may be appropriate (counts, in_place, etc) */ 
    309312        } 
    310313        MPID_END_ERROR_CHECKS 
  • src/mpi/coll/igather.c

    ra31d19 r408629  
    650650 
    651651                    /* catch common aliasing cases */ 
    652                     if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && sendcount != 0) 
    653                         MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
     652                    if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && sendcount != 0) { 
     653                        int recvtype_size; 
     654                        MPID_Datatype_get_size_macro(recvtype, recvtype_size); 
     655                        MPIR_ERRTEST_ALIAS_COLL(sendbuf, (char*)recvbuf + comm_ptr->rank*recvcount*recvtype_size, mpi_errno); 
     656                    } 
    654657                } 
    655658                else 
  • src/mpi/coll/igatherv.c

    r7d9833 r408629  
    257257                        } 
    258258                    } 
     259 
     260                    /* catch common aliasing cases */ 
     261                    if (sendbuf != MPI_IN_PLACE && sendtype == recvtype && recvcounts[comm_ptr->rank] != 0 && sendcount != 0) { 
     262                        int recvtype_size; 
     263                        MPID_Datatype_get_size_macro(recvtype, recvtype_size); 
     264                        MPIR_ERRTEST_ALIAS_COLL(sendbuf, (char*)recvbuf + displs[comm_ptr->rank]*recvtype_size, mpi_errno); 
     265                    } 
    259266                } 
    260267                else 
  • src/mpi/coll/ired_scat.c

    r893492 r408629  
    11341134 
    11351135            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
    1136             /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
     1136 
     1137            if (comm_ptr->comm_kind == MPID_INTRACOMM && sendbuf != MPI_IN_PLACE) 
     1138                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno) 
     1139            /* TODO more checks may be appropriate (counts, in_place, etc) */ 
    11371140        } 
    11381141        MPID_END_ERROR_CHECKS 
  • src/mpi/coll/ired_scat_block.c

    r893492 r408629  
    10351035 
    10361036            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
    1037             /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
     1037 
     1038            if (comm_ptr->comm_kind == MPID_INTRACOMM && sendbuf != MPI_IN_PLACE) 
     1039                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno) 
     1040            /* TODO more checks may be appropriate (counts, in_place, etc) */ 
    10381041        } 
    10391042        MPID_END_ERROR_CHECKS 
  • src/mpi/coll/ireduce.c

    r8ea1dfe r408629  
    863863        MPID_BEGIN_ERROR_CHECKS 
    864864        { 
     865            int rank; 
     866 
    865867            MPID_Comm_valid_ptr(comm_ptr, mpi_errno); 
    866868            if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) { 
     
    884886 
    885887            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
    886             /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
     888 
     889            if (comm_ptr->comm_kind == MPID_INTRACOMM) { 
     890                if (sendbuf != MPI_IN_PLACE) 
     891                    MPIR_ERRTEST_USERBUFFER(sendbuf,count,datatype,mpi_errno); 
     892 
     893                rank = comm_ptr->rank; 
     894                if (rank == root) { 
     895                    MPIR_ERRTEST_RECVBUF_INPLACE(recvbuf, count, mpi_errno); 
     896                    MPIR_ERRTEST_USERBUFFER(recvbuf,count,datatype,mpi_errno); 
     897                    if (count != 0 && sendbuf != MPI_IN_PLACE) { 
     898                        MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
     899                    } 
     900                } 
     901                else 
     902                    MPIR_ERRTEST_SENDBUF_INPLACE(sendbuf, count, mpi_errno); 
     903            } 
     904 
     905            /* TODO more checks may be appropriate (counts, in_place, etc) */ 
    887906        } 
    888907        MPID_END_ERROR_CHECKS 
  • src/mpi/coll/iscan.c

    ra31d19 r408629  
    442442 
    443443            MPIR_ERRTEST_ARGNULL(request,"request", mpi_errno); 
    444             /* TODO more checks may be appropriate (counts, in_place, buffer aliasing, etc) */ 
     444 
     445            if (sendbuf != MPI_IN_PLACE) 
     446                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
     447            /* TODO more checks may be appropriate (counts, in_place, etc) */ 
    445448        } 
    446449        MPID_END_ERROR_CHECKS 
  • src/mpi/coll/iscatter.c

    r95ca21 r408629  
    666666 
    667667                    /* catch common aliasing cases */ 
    668                     if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && recvcount != 0) 
    669                         MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
     668                    if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && recvcount != 0) { 
     669                        int sendtype_size; 
     670                        MPID_Datatype_get_size_macro(sendtype, sendtype_size); 
     671                        MPIR_ERRTEST_ALIAS_COLL(recvbuf, (char*)sendbuf + comm_ptr->rank*sendcount*sendtype_size, mpi_errno); 
     672                    } 
    670673                } 
    671674                else 
  • src/mpi/coll/iscatterv.c

    r7d9833 r408629  
    257257                        } 
    258258                    } 
     259                    /* catch common aliasing cases */ 
     260                    if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcounts[comm_ptr->rank] != 0 && recvcount != 0) { 
     261                        int sendtype_size; 
     262                        MPID_Datatype_get_size_macro(sendtype, sendtype_size); 
     263                        MPIR_ERRTEST_ALIAS_COLL(recvbuf, (char*)sendbuf + displs[comm_ptr->rank]*sendtype_size, mpi_errno); 
     264                    } 
     265 
    259266                } 
    260267                else 
  • src/mpi/coll/red_scat.c

    r8c133e r408629  
    11731173 
    11741174            MPIR_ERRTEST_RECVBUF_INPLACE(recvbuf, recvcounts[comm_ptr->rank], mpi_errno); 
    1175             if (comm_ptr->comm_kind == MPID_INTERCOMM)  
     1175            if (comm_ptr->comm_kind == MPID_INTERCOMM) { 
    11761176                MPIR_ERRTEST_SENDBUF_INPLACE(sendbuf, sum, mpi_errno); 
     1177            } else if (sendbuf != MPI_IN_PLACE) 
     1178                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno) 
    11771179 
    11781180            MPIR_ERRTEST_USERBUFFER(recvbuf,recvcounts[comm_ptr->rank],datatype,mpi_errno); 
  • src/mpi/coll/red_scat_block.c

    r2f4324 r408629  
    11371137 
    11381138            MPIR_ERRTEST_RECVBUF_INPLACE(recvbuf, recvcount, mpi_errno); 
    1139             if (comm_ptr->comm_kind == MPID_INTERCOMM)  
     1139            if (comm_ptr->comm_kind == MPID_INTERCOMM) { 
    11401140                MPIR_ERRTEST_SENDBUF_INPLACE(sendbuf, recvcount, mpi_errno); 
     1141            } else if (sendbuf != MPI_IN_PLACE) 
     1142                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno) 
    11411143 
    11421144            MPIR_ERRTEST_USERBUFFER(recvbuf,recvcount,datatype,mpi_errno); 
  • src/mpi/coll/scan.c

    re98feb r408629  
    549549            } 
    550550            if (mpi_errno != MPI_SUCCESS) goto fn_fail; 
     551 
     552            if (sendbuf != MPI_IN_PLACE) 
     553                MPIR_ERRTEST_ALIAS_COLL(sendbuf, recvbuf, mpi_errno); 
    551554        } 
    552555        MPID_END_ERROR_CHECKS; 
  • src/mpi/coll/scatter.c

    r8c133e r408629  
    725725 
    726726                    /* catch common aliasing cases */ 
    727                     if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && recvcount != 0) 
    728                         MPIR_ERRTEST_ALIAS_COLL(sendbuf,recvbuf,mpi_errno); 
    729                 } 
    730                 else  
     727                    if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcount == recvcount && recvcount != 0) { 
     728                        int sendtype_size; 
     729                        MPID_Datatype_get_size_macro(sendtype, sendtype_size); 
     730                        MPIR_ERRTEST_ALIAS_COLL(recvbuf, (char*)sendbuf + comm_ptr->rank*sendcount*sendtype_size, mpi_errno); 
     731                    } 
     732                } 
     733                else 
    731734                    MPIR_ERRTEST_RECVBUF_INPLACE(recvbuf, recvcount, mpi_errno); 
    732735 
  • src/mpi/coll/scatterv.c

    rb9531d r408629  
    294294                        } 
    295295                    } 
     296                    /* catch common aliasing cases */ 
     297                    if (recvbuf != MPI_IN_PLACE && sendtype == recvtype && sendcounts[comm_ptr->rank] != 0 && recvcount != 0) { 
     298                        int sendtype_size; 
     299                        MPID_Datatype_get_size_macro(sendtype, sendtype_size); 
     300                        MPIR_ERRTEST_ALIAS_COLL(recvbuf, (char*)sendbuf + displs[comm_ptr->rank]*sendtype_size, mpi_errno); 
     301                    } 
    296302                } 
    297303                else  
Note: See TracChangeset for help on using the changeset viewer.