teshsuite/smpi/MBI/generator_utils.py

   1 # Copyright 2021-2022. The MBI project. All rights reserved.
   2 # This program is free software; you can redistribute it and/or modify it under the terms of the license (GNU GPL).
   3
   4 # This is a simple templating system, dedicated to the systematic generation of MPI source code
   5
   6 import os
   7 import re
   8
   9 # Collectives
  10 coll = ['MPI_Barrier', 'MPI_Bcast', 'MPI_Reduce', 'MPI_Gather', 'MPI_Scatter', 'MPI_Scan', 'MPI_Exscan', 'MPI_Allgather', 'MPI_Allreduce', 'MPI_Allgatherv', 'MPI_Alltoall', 'MPI_Alltoallv']
  11 icoll = ['MPI_Ibcast', 'MPI_Ireduce', 'MPI_Igather', 'MPI_Iscatter', 'MPI_Iscan', 'MPI_Iexscan', 'MPI_Iallgather', 'MPI_Iallreduce', 'MPI_Iallgatherv', 'MPI_Ialltoall', 'MPI_Ialltoallv']
  12 ibarrier = ['MPI_Ibarrier']
  13 coll4op = ['MPI_Reduce', 'MPI_Allreduce']
  14 icoll4op = ['MPI_Ireduce', 'MPI_Iallreduce']
  15 coll4root = ['MPI_Reduce', 'MPI_Bcast', 'MPI_Gather', 'MPI_Scatter']
  16 icoll4root = ['MPI_Ireduce', 'MPI_Ibcast', 'MPI_Igather', 'MPI_Iscatter']
  17 pcoll = []
  18 tcoll = ['MPI_Comm_split', 'MPI_Op_create', 'MPI_Comm_dup', 'MPI_Type_contiguous', 'MPI_Comm_create', 'MPI_Group_excl'] # MPI_Comm_dup removed
  19 tcoll4color = ['MPI_Comm_split']
  20 tcoll4topo = ['MPI_Cart_get']
  21
  22 # P2P
  23 allsend = ['MPI_Send', 'MPI_Isend', 'MPI_Ssend', 'MPI_Bsend', 'MPI_Send_init']
  24 allrecv = ['MPI_Recv', 'MPI_Irecv', 'MPI_Recv_init']
  25 send = ['MPI_Send']
  26 ssend = ['MPI_Ssend']
  27 bsend = ['MPI_Bsend']
  28 isend = ['MPI_Isend']
  29 psend = ['MPI_Send_init']
  30 recv = ['MPI_Recv']
  31 irecv = ['MPI_Irecv']
  32 precv = ['MPI_Recv_init']
  33 probe = ['MPI_Probe']
  34
  35 # RMA
  36 epoch = ['MPI_Win_fence', 'MPI_Win_lock', 'MPI_Win_lock_all']
  37 rma = ['MPI_Get', 'MPI_Put']
  38 get = ['MPI_Get']
  39 put = ['MPI_Put']
  40 store = ['store']
  41 load = ['load']
  42 rstore = ['rstore']
  43 rload = ['rload']
  44 loadstore = ['loadstore']
  45
  46
  47 # setup
  48 init = {}
  49 start = {}
  50 operation = {}
  51 fini = {}
  52 free = {}
  53 write = {}
  54 error = {}
  55 epoch = {}
  56 finEpoch = {}
  57
  58
  59 ### COLL:basic
  60
  61 init['MPI_Bcast'] = lambda n: f'int buf{n}[buff_size];'
  62 start['MPI_Bcast'] = lambda n: ""
  63 operation['MPI_Bcast'] = lambda n: f'MPI_Bcast(buf{n}, buff_size, type, root, newcom);'
  64 fini['MPI_Bcast'] = lambda n: ""
  65 free['MPI_Bcast'] = lambda n: ""
  66 write['MPI_Bcast'] = lambda n: ""
  67
  68 init['MPI_Barrier'] = lambda n: ""
  69 start['MPI_Barrier'] = lambda n: ""
  70 operation['MPI_Barrier'] = lambda n: 'MPI_Barrier(newcom);'
  71 fini['MPI_Barrier'] = lambda n: ""
  72 free['MPI_Barrier'] = lambda n: ""
  73 write['MPI_Barrier'] = lambda n: ""
  74
  75 init['MPI_Reduce'] = lambda n: f"int sum{n}, val{n} = 1;"
  76 start['MPI_Reduce'] = lambda n: ""
  77 operation['MPI_Reduce'] = lambda n: f"MPI_Reduce(&val{n}, &sum{n}, 1, type, op, root, newcom);"
  78 fini['MPI_Reduce'] = lambda n: ""
  79 free['MPI_Reduce'] = lambda n: ""
  80 write['MPI_Reduce'] = lambda n: ""
  81
  82 init['MPI_Gather'] = lambda n: f"int val{n}=1, buf{n}[buff_size];"
  83 start['MPI_Gather'] = lambda n: ""
  84 operation['MPI_Gather'] = lambda n: f"MPI_Gather(&val{n}, 1, type, buf{n},1, type, root, newcom);"
  85 fini['MPI_Gather'] = lambda n: ""
  86 free['MPI_Gather'] = lambda n: ""
  87 write['MPI_Gather'] = lambda n: ""
  88
  89 init['MPI_Scatter'] = lambda n: f"int val{n}, buf{n}[buff_size];"
  90 start['MPI_Scatter'] = lambda n: ""
  91 operation['MPI_Scatter'] = lambda n: f"MPI_Scatter(&buf{n}, 1, type, &val{n}, 1, type, root, newcom);"
  92 fini['MPI_Scatter'] = lambda n: ""
  93 free['MPI_Scatter'] = lambda n: ""
  94 write['MPI_Scatter'] = lambda n: ""
  95
  96 init['MPI_Allreduce'] = lambda n: f"int sum{n}, val{n} = 1;"
  97 start['MPI_Allreduce'] = lambda n: ""
  98 operation['MPI_Allreduce'] = lambda n: f"MPI_Allreduce(&val{n}, &sum{n}, 1, type, op, newcom);"
  99 fini['MPI_Allreduce'] = lambda n: ""
 100 free['MPI_Allreduce'] = lambda n: ""
 101 write['MPI_Allreduce'] = lambda n: ""
 102
 103 init['MPI_Scan'] = lambda n: f"int outbuf{n}[buff_size];\n  memset(outbuf{n}, 0, buff_size*sizeof(int));\n  int inbuf{n}[buff_size];"
 104 start['MPI_Scan'] = lambda n: ""
 105 operation['MPI_Scan'] = lambda n: f"MPI_Scan(&outbuf{n}, inbuf{n}, buff_size, type, op, newcom);"
 106 fini['MPI_Scan'] = lambda n: ""
 107 free['MPI_Scan'] = lambda n: ""
 108 write['MPI_Scan'] = lambda n: ""
 109
 110 init['MPI_Exscan'] = lambda n: f"int outbuf{n}[buff_size];\n  memset(outbuf{n}, 0, buff_size*sizeof(int));\n  int inbuf{n}[buff_size];"
 111 start['MPI_Exscan'] = lambda n: ""
 112 operation['MPI_Exscan'] = lambda n: f"MPI_Exscan(&outbuf{n}, inbuf{n}, buff_size, type, op, newcom);"
 113 fini['MPI_Exscan'] = lambda n: ""
 114 free['MPI_Exscan'] = lambda n: ""
 115 write['MPI_Exscan'] = lambda n: ""
 116
 117 init['MPI_Allgather'] = lambda n: f"int val{n}=1, *rbuf{n} = (int*)malloc(dbs);"
 118 start['MPI_Allgather'] = lambda n: ""
 119 operation['MPI_Allgather'] = lambda n: f"MPI_Allgather(&val{n}, 1, type, rbuf{n}, 1, type, newcom);"
 120 fini['MPI_Allgather'] = lambda n: ""
 121 free['MPI_Allgather'] = lambda n: f"free(rbuf{n});"
 122 write['MPI_Allgather'] = lambda n: ""
 123
 124 init['MPI_Alltoallv'] = lambda n: (f"int *sbuf{n}=(int*)malloc(dbs*2), *rbuf{n}=(int*)malloc(dbs*2), *scounts{n}=(int*)malloc(dbs), *rcounts{n}=(int*)malloc(dbs), *sdispls{n}=(int*)malloc(dbs), *rdispls{n}=(int*)malloc(dbs);\n"
 125   +  "  for (int i = 0; i < nprocs; i++) {\n"
 126   + f"    scounts{n}[i] = 2;\n"
 127   + f"    rcounts{n}[i] = 2;\n"
 128   + f"    sdispls{n}[i] = (nprocs - (i + 1)) * 2;\n"
 129   + f"    rdispls{n}[i] = i * 2;\n"
 130   +  "  }")
 131 start['MPI_Alltoallv'] = lambda n: ""
 132 operation['MPI_Alltoallv'] = lambda n: f"MPI_Alltoallv(sbuf{n}, scounts{n}, sdispls{n}, type, rbuf{n}, rcounts{n}, rdispls{n}, type, newcom);"
 133 fini['MPI_Alltoallv'] = lambda n: ""
 134 free['MPI_Alltoallv'] = lambda n: f"free(sbuf{n});free(rbuf{n});free(scounts{n});free(rcounts{n});free(sdispls{n});free(rdispls{n});"
 135 write['MPI_Alltoallv'] = lambda n: ""
 136
 137 init['MPI_Alltoall'] = lambda n: f"int *sbuf{n} = (int*)malloc(dbs), *rbuf{n} = (int*)malloc(dbs);"
 138 start['MPI_Alltoall'] = lambda n: ""
 139 operation['MPI_Alltoall'] = lambda n: f"MPI_Alltoall(sbuf{n}, 1, type, rbuf{n}, 1, type, newcom);"
 140 fini['MPI_Alltoall'] = lambda n: ""
 141 free['MPI_Alltoall'] = lambda n: f"free(sbuf{n});free(rbuf{n});"
 142 write['MPI_Alltoall'] = lambda n: ""
 143
 144 init['MPI_Allgatherv'] = lambda n: (f"int *rbuf{n} = (int*)malloc(dbs*2), *rcounts{n}=(int*)malloc(dbs),  *displs{n}=(int*)malloc(dbs);\n"
 145   +  "  for (int i = 0; i < nprocs; i++) {\n"
 146   + f"    rcounts{n}[i] = 1;\n"
 147   + f"    displs{n}[i] = 2 * (nprocs - (i + 1));\n"
 148   +  "  }")
 149 start['MPI_Allgatherv'] = lambda n: ""
 150 operation['MPI_Allgatherv'] = lambda n: f"MPI_Allgatherv(&rank, 1, type, rbuf{n}, rcounts{n}, displs{n}, type, newcom);"
 151 fini['MPI_Allgatherv'] = lambda n: ""
 152 free['MPI_Allgatherv'] = lambda n: f"free(rbuf{n});free(rcounts{n});free(displs{n});"
 153 write['MPI_Allgatherv'] = lambda n: ""
 154
 155
 156 ### COLL:nonblocking
 157
 158 init['MPI_Ibarrier'] = lambda n: f"MPI_Request req{n}=MPI_REQUEST_NULL; MPI_Status stat{n};"
 159 start['MPI_Ibarrier'] = lambda n: ""
 160 operation['MPI_Ibarrier'] = lambda n: f'MPI_Ibarrier(newcom, &req{n});'
 161 fini['MPI_Ibarrier'] = lambda n: f"MPI_Wait(&req{n}, &stat{n});"
 162 free['MPI_Ibarrier'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 163 write['MPI_Ibarrier'] = lambda n: ""
 164
 165 init['MPI_Ireduce'] = lambda n: f"MPI_Request req{n}=MPI_REQUEST_NULL; MPI_Status stat{n}; int sum{n}, val{n} = 1;"
 166 start['MPI_Ireduce'] = lambda n: ""
 167 operation['MPI_Ireduce'] = lambda n: f"MPI_Ireduce(&val{n}, &sum{n}, 1, type, op, root, newcom, &req{n});"
 168 fini['MPI_Ireduce'] = lambda n: f"MPI_Wait(&req{n}, &stat{n});"
 169 free['MPI_Ireduce'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 170 write['MPI_Ireduce'] = lambda n: f"sum{n}++;"
 171
 172 init['MPI_Iallreduce'] = lambda n: f'MPI_Request req{n}=MPI_REQUEST_NULL;MPI_Status stat{n}; int sum{n}, val{n} = 1;'
 173 start['MPI_Iallreduce'] = lambda n: ""
 174 operation['MPI_Iallreduce'] = lambda n: f'MPI_Iallreduce(&val{n}, &sum{n}, 1, type, op, newcom, &req{n});'
 175 fini['MPI_Iallreduce'] = lambda n: f'MPI_Wait(&req{n}, &stat{n});'
 176 free['MPI_Iallreduce'] = lambda n: f"if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});"
 177 write['MPI_Iallreduce'] = lambda n: f"sum{n}++;"
 178
 179 init['MPI_Ibcast'] = lambda n: f'MPI_Request req{n}=MPI_REQUEST_NULL; MPI_Status sta{n};int buf{n}[buff_size];'
 180 start['MPI_Ibcast'] = lambda n: ""
 181 operation['MPI_Ibcast'] = lambda n: f'MPI_Ibcast(buf{n}, buff_size, type, root, newcom, &req{n});'
 182 fini['MPI_Ibcast'] = lambda n: f"MPI_Wait(&req{n},&sta{n});"
 183 free['MPI_Ibcast'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 184 write['MPI_Ibcast'] = lambda n: f'buf{n}[0]++;'
 185
 186 init['MPI_Igather'] = lambda n: f"int val{n}=1, buf{n}[buff_size];MPI_Request req{n}=MPI_REQUEST_NULL;MPI_Status sta{n};"
 187 start['MPI_Igather'] = lambda n: ""
 188 operation['MPI_Igather'] = lambda n: f'MPI_Igather(&val{n}, 1, type, &buf{n},1, type, root, newcom, &req{n});'
 189 write['MPI_Igather'] = lambda n: f'val{n}=3;'
 190 fini['MPI_Igather'] = lambda n: f'MPI_Wait(&req{n},&sta{n});'
 191 free['MPI_Igather'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 192
 193 init['MPI_Iscatter'] = lambda n: f"MPI_Request req{n} = MPI_REQUEST_NULL;\n  MPI_Status sta{n};\n  int val{n};\n  int buf{n}[buff_size];\n  memset(buf{n}, 0, buff_size*sizeof(int));"
 194 start['MPI_Iscatter'] = lambda n: ""
 195 operation['MPI_Iscatter'] = lambda n: f"MPI_Iscatter(&buf{n}, 1, type, &val{n}, 1, type, root, newcom,&req{n});"
 196 fini['MPI_Iscatter'] = lambda n: f"MPI_Wait(&req{n},&sta{n});"
 197 free['MPI_Iscatter'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 198 write['MPI_Iscatter'] = lambda n: f'buf{n}[0]++;'
 199
 200 init['MPI_Iscan'] = lambda n: f"MPI_Request req{n} = MPI_REQUEST_NULL;\n  MPI_Status sta{n};\n  int outbuf{n}[buff_size];\n  memset(outbuf{n}, 0, buff_size*sizeof(int));\n  int inbuf{n}[buff_size];"
 201 start['MPI_Iscan'] = lambda n: ""
 202 operation['MPI_Iscan'] = lambda n: f"MPI_Iscan(&outbuf{n}, inbuf{n}, buff_size, type, op, newcom,&req{n});"
 203 fini['MPI_Iscan'] = lambda n: f"MPI_Wait(&req{n},&sta{n});"
 204 free['MPI_Iscan'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 205 write['MPI_Iscan'] = lambda n: f'outbuf{n}[0]++;'
 206
 207 init['MPI_Iexscan'] = lambda n: f"MPI_Request req{n}=MPI_REQUEST_NULL;MPI_Status sta{n};\n  int outbuf{n}[buff_size];\n  memset(outbuf{n}, 0, buff_size*sizeof(int));\n  int inbuf{n}[buff_size];"
 208 start['MPI_Iexscan'] = lambda n: ""
 209 operation['MPI_Iexscan'] = lambda n: f"MPI_Iexscan(&outbuf{n}, inbuf{n}, buff_size, type, op, newcom,&req{n});"
 210 fini['MPI_Iexscan'] = lambda n: f"MPI_Wait(&req{n},&sta{n});"
 211 free['MPI_Iexscan'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 212 write['MPI_Iexscan'] = lambda n: f'outbuf{n}[0]++;'
 213
 214 init['MPI_Iallgather'] = lambda n: f"MPI_Request req{n}=MPI_REQUEST_NULL;MPI_Status sta{n};int val{n}=1, *rbuf{n} = (int*)malloc(dbs);"
 215 start['MPI_Iallgather'] = lambda n: ""
 216 operation['MPI_Iallgather'] = lambda n: f"MPI_Iallgather(&val{n}, 1, type, rbuf{n}, 1, type, newcom,&req{n});"
 217 fini['MPI_Iallgather'] = lambda n: f"MPI_Wait(&req{n},&sta{n});"
 218 free['MPI_Iallgather'] = lambda n: f"free(rbuf{n});"
 219 write['MPI_Iallgather'] = lambda n: f'val{n}++;'
 220
 221 init['MPI_Iallgatherv'] = lambda n: (f"MPI_Request req{n}=MPI_REQUEST_NULL;MPI_Status sta{n};int *rbuf{n} = (int*)malloc(dbs*2), *rcounts{n}=(int*)malloc(dbs),  *displs{n}=(int*)malloc(dbs);\n"
 222   +  "  for (int i = 0; i < nprocs; i++) {\n"
 223   + f"    rcounts{n}[i] = 1;\n"
 224   + f"    displs{n}[i] = 2 * (nprocs - (i + 1));\n"
 225   +  "  }")
 226 start['MPI_Iallgatherv'] = lambda n: ""
 227 operation['MPI_Iallgatherv'] = lambda n: f"MPI_Iallgatherv(&rank, 1, type, rbuf{n}, rcounts{n}, displs{n}, type, newcom,&req{n});"
 228 fini['MPI_Iallgatherv'] = lambda n: f"MPI_Wait(&req{n},&sta{n});"
 229 free['MPI_Iallgatherv'] = lambda n: f"free(rbuf{n});free(rcounts{n});free(displs{n});"
 230 write['MPI_Iallgatherv'] = lambda n: f"rbuf{n}[0]++;"
 231
 232 init['MPI_Ialltoall'] = lambda n: f"MPI_Request req{n}=MPI_REQUEST_NULL;MPI_Status sta{n};int *sbuf{n} = (int*)malloc(dbs), *rbuf{n} = (int*)malloc(dbs);"
 233 start['MPI_Ialltoall'] = lambda n: ""
 234 operation['MPI_Ialltoall'] = lambda n: f"MPI_Ialltoall(sbuf{n}, 1, type, rbuf{n}, 1, type, newcom, &req{n});"
 235 fini['MPI_Ialltoall'] = lambda n: f"MPI_Wait(&req{n},&sta{n});"
 236 free['MPI_Ialltoall'] = lambda n: f"free(sbuf{n});free(rbuf{n});"
 237 write['MPI_Ialltoall'] = lambda n: f"rbuf{n}[0]++;"
 238
 239 init['MPI_Ialltoallv'] = lambda n: (f"MPI_Request req{n}=MPI_REQUEST_NULL;MPI_Status sta{n};int *sbuf{n}=(int*)malloc(dbs*2), *rbuf{n}=(int*)malloc(dbs*2), *scounts{n}=(int*)malloc(dbs), *rcounts{n}=(int*)malloc(dbs), *sdispls{n}=(int*)malloc(dbs), *rdispls{n}=(int*)malloc(dbs);\n"
 240   +  "  for (int i = 0; i < nprocs; i++) {\n"
 241   + f"    scounts{n}[i] = 2;\n"
 242   + f"    rcounts{n}[i] = 2;\n"
 243   + f"    sdispls{n}[i] = (nprocs - (i + 1)) * 2;\n"
 244   + f"    rdispls{n}[i] = i * 2;\n"
 245   +  "  }")
 246 start['MPI_Ialltoallv'] = lambda n: ""
 247 operation['MPI_Ialltoallv'] = lambda n: f"MPI_Ialltoallv(sbuf{n}, scounts{n}, sdispls{n}, type, rbuf{n}, rcounts{n}, rdispls{n}, type, newcom,&req{n});"
 248 fini['MPI_Ialltoallv'] = lambda n: f"MPI_Wait(&req{n},&sta{n});"
 249 free['MPI_Ialltoallv'] = lambda n: f"free(sbuf{n});free(rbuf{n});free(scounts{n});free(rcounts{n});free(sdispls{n});free(rdispls{n});"
 250 write['MPI_Ialltoallv'] = lambda n: f"rbuf{n}[0]++;"
 251
 252 ### COLL:persistent
 253
 254
 255
 256 ### COLL:tools
 257
 258 init['MPI_Comm_split'] = lambda n: f'MPI_Comm com[size]; color = rank % 2; int key = 1;'
 259 start['MPI_Comm_split'] = lambda n: ""
 260 operation['MPI_Comm_split'] = lambda n: 'MPI_Comm_split(MPI_COMM_WORLD,color,key, &com[j]);'
 261 error['MPI_Comm_split'] = 'CommunicatorLeak'
 262 fini['MPI_Comm_split'] = lambda n: "if(com[j] != MPI_COMM_NULL) MPI_Comm_free(&com[j]);"
 263 free['MPI_Comm_split'] = lambda n: ""
 264
 265
 266 init['MPI_Cart_get'] = lambda n: ""
 267 start['MPI_Cart_get'] = lambda n: ""
 268 operation['MPI_Cart_get'] = lambda n: f'MPI_Cart_get(newcom, 2, dims, periods, coords);'
 269 write['MPI_Cart_get'] = lambda n: ""
 270 fini['MPI_Cart_get'] = lambda n: ""
 271 free['MPI_Cart_get'] = lambda n: ""
 272
 273
 274 init['MPI_Op_create'] = lambda n: 'MPI_Op op[size];'
 275 operation['MPI_Op_create'] = lambda n: 'MPI_Op_create((MPI_User_function *)myOp, 0, &op[j]);'
 276 error['MPI_Op_create'] = 'OperatorLeak'
 277 fini['MPI_Op_create'] = lambda n: "MPI_Op_free(&op[j]);"
 278 free['MPI_Op_create'] = lambda n: ""
 279
 280 init['MPI_Comm_group'] = lambda n: 'MPI_Group grp[size];'
 281 operation['MPI_Comm_group'] = lambda n: 'MPI_Comm_group(MPI_COMM_WORLD, &grp[j]);'
 282 error['MPI_Comm_group'] = 'GroupLeak'
 283 fini['MPI_Comm_group'] = lambda n: "MPI_Group_free(&grp[j]);"
 284 free['MPI_Comm_group'] = lambda n: ""
 285
 286 init['MPI_Group_excl'] = lambda n: 'MPI_Group worldgroup, grp[size];\n MPI_Comm_group(MPI_COMM_WORLD, &worldgroup);'
 287 operation['MPI_Group_excl'] = lambda n: 'MPI_Group_excl(worldgroup, 1, &rank, &grp[j]);'
 288 error['MPI_Group_excl'] = 'GroupLeak'
 289 fini['MPI_Group_excl'] = lambda n: "MPI_Group_free(&grp[j]);"
 290 free['MPI_Group_excl'] = lambda n: "MPI_Group_free(&worldgroup);"
 291
 292 init['MPI_Comm_create'] = lambda n: 'MPI_Comm com[size]; MPI_Group grp[size];'
 293 operation['MPI_Comm_create'] = lambda n: 'MPI_Comm_group(MPI_COMM_WORLD, &grp[j]);\n MPI_Comm_create(MPI_COMM_WORLD, grp[j], &com[j]);\n MPI_Group_free(&grp[j]);'
 294 error['MPI_Comm_create'] = 'CommunicatorLeak'
 295 fini['MPI_Comm_create'] = lambda n: "MPI_Comm_free(&com[j]);"
 296 free['MPI_Comm_create'] = lambda n: ""
 297
 298 init['MPI_Comm_dup'] = lambda n: f'MPI_Comm com[size];'
 299 operation['MPI_Comm_dup'] = lambda n: 'MPI_Comm_dup(MPI_COMM_WORLD, &com[j]);'
 300 error['MPI_Comm_dup'] = 'CommunicatorLeak'
 301 fini['MPI_Comm_dup'] = lambda n: "MPI_Comm_free(&com[j]);"
 302 free['MPI_Comm_dup'] = lambda n: ""
 303
 304 init['MPI_Type_contiguous'] = lambda n: 'MPI_Datatype type[size];'
 305 operation['MPI_Type_contiguous'] = lambda n: 'MPI_Type_contiguous(2, MPI_DOUBLE, &type[j]);'
 306 error['MPI_Type_contiguous'] = 'TypeLeak'
 307 fini['MPI_Type_contiguous'] = lambda n: "MPI_Type_free(&type[j]);"
 308 free['MPI_Type_contiguous'] = lambda n: ""
 309
 310
 311
 312
 313 ### P2P:basic
 314
 315 init['MPI_Send'] = lambda n: f'int buf{n}=rank;'
 316 start['MPI_Send'] = lambda n: ""
 317 operation['MPI_Send'] = lambda n: f'MPI_Send(&buf{n}, buff_size, type, dest, stag, newcom);'
 318 fini['MPI_Send'] = lambda n: ""
 319 free['MPI_Send'] = lambda n: ""
 320 write['MPI_Send'] = lambda n: ""
 321
 322 init['MPI_Ssend'] = lambda n: f'int buf{n}=rank;'
 323 start['MPI_Ssend'] = lambda n: ""
 324 operation['MPI_Ssend'] = lambda n: f'MPI_Ssend(&buf{n}, buff_size, type, dest, stag, newcom);'
 325 fini['MPI_Ssend'] = lambda n: ""
 326 free['MPI_Ssend'] = lambda n: ""
 327 write['MPI_Ssend'] = lambda n: ""
 328
 329 init['MPI_Bsend'] = lambda n: (f'int buf{n}=rank;\n'
 330             + f'int buffer_attached_size{n} = MPI_BSEND_OVERHEAD + sizeof(int);\n'
 331             + f'char* buffer_attached{n} = (char*)malloc(buffer_attached_size{n});\n'
 332             + f'MPI_Buffer_attach(buffer_attached{n}, buffer_attached_size{n});')
 333 start['MPI_Bsend'] = lambda n: ""
 334 operation['MPI_Bsend'] = lambda n: f'MPI_Bsend(&buf{n}, buff_size, type, dest, stag, newcom);'
 335 fini['MPI_Bsend'] = lambda n: ""
 336 free['MPI_Bsend'] = (lambda n: f'MPI_Buffer_detach(&buffer_attached{n}, &buffer_attached_size{n});\n'
 337             + f'free(buffer_attached{n});')
 338 write['MPI_Bsend'] = lambda n: ""
 339
 340 init['MPI_Recv'] = lambda n: f'int buf{n}=-1; MPI_Status sta{n};'
 341 start['MPI_Recv'] = lambda n: ""
 342 operation['MPI_Recv'] = lambda n: f'MPI_Recv(&buf{n}, buff_size, type, src, rtag, newcom, &sta{n});'
 343 fini['MPI_Recv'] = lambda n: ""
 344 free['MPI_Recv'] = lambda n: ""
 345 write['MPI_Recv'] = lambda n: ""
 346
 347 init['MPI_Probe'] = lambda n: ""
 348 start['MPI_Probe'] = lambda n: ""
 349 operation['MPI_Probe'] = lambda n: f'MPI_Probe(src, 0, newcom, &sta);'
 350 fini['MPI_Probe'] = lambda n: ""
 351 free['MPI_Probe'] = lambda n: ""
 352 write['MPI_Probe'] = lambda n: ""
 353
 354
 355
 356 ### P2P:nonblocking
 357
 358 init['MPI_Isend'] = lambda n: f'int buf{n}=rank; MPI_Request req{n}=MPI_REQUEST_NULL;'
 359 start['MPI_Isend'] = lambda n: ""
 360 operation['MPI_Isend'] = lambda n: f'MPI_Isend(&buf{n}, buff_size, type, dest, stag, newcom, &req{n});'
 361 fini['MPI_Isend'] = lambda n: f'MPI_Wait(&req{n}, MPI_STATUS_IGNORE);'
 362 free['MPI_Isend'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 363 write['MPI_Isend'] = lambda n: f'buf{n}=4;'
 364
 365 init['MPI_Irecv'] = lambda n: f'int buf{n}=-1; MPI_Request req{n}=MPI_REQUEST_NULL;'
 366 start['MPI_Irecv'] = lambda n: ""
 367 operation['MPI_Irecv'] = lambda n: f'MPI_Irecv(&buf{n}, buff_size, type, src, rtag, newcom, &req{n});'
 368 fini['MPI_Irecv'] = lambda n: f' MPI_Wait(&req{n}, MPI_STATUS_IGNORE);'
 369 free['MPI_Irecv'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 370 write['MPI_Irecv'] = lambda n: f'buf{n}++;'
 371
 372 ### P2P:persistent
 373
 374 init['MPI_Send_init'] = lambda n: f'int buf{n}=rank; MPI_Request req{n}=MPI_REQUEST_NULL;'
 375 operation['MPI_Send_init'] = lambda n: f'MPI_Send_init(&buf{n}, buff_size, type, dest, stag, newcom, &req{n});'
 376 start['MPI_Send_init'] = lambda n: f'MPI_Start(&req{n});'
 377 fini['MPI_Send_init'] = lambda n: f'MPI_Wait(&req{n}, MPI_STATUS_IGNORE);'
 378 free['MPI_Send_init'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 379 write['MPI_Send_init'] = lambda n: f'buf{n}=4;'
 380
 381 init['MPI_Recv_init'] = lambda n: f'int buf{n}=-1; MPI_Request req{n}=MPI_REQUEST_NULL;'
 382 start['MPI_Recv_init'] = lambda n: f'MPI_Start(&req{n});'
 383 operation['MPI_Recv_init'] = lambda n: f'MPI_Recv_init(&buf{n}, buff_size, type, src, rtag, newcom, &req{n});'
 384 fini['MPI_Recv_init'] = lambda n: f'MPI_Wait(&req{n}, MPI_STATUS_IGNORE);'
 385 free['MPI_Recv_init'] = lambda n: f'if(req{n} != MPI_REQUEST_NULL) MPI_Request_free(&req{n});'
 386 write['MPI_Recv_init'] = lambda n: f'buf{n}++;'
 387
 388 ### RMA
 389
 390 epoch['MPI_Win_fence'] = lambda n: 'MPI_Win_fence(0, win);'
 391 finEpoch['MPI_Win_fence'] = lambda n: 'MPI_Win_fence(0, win);'
 392 epoch['MPI_Win_lock'] = lambda n: 'MPI_Win_lock(MPI_LOCK_SHARED, target, 0, win);'
 393 finEpoch['MPI_Win_lock'] = lambda n: 'MPI_Win_unlock(target, win);'
 394 epoch['MPI_Win_lock_all'] = lambda n: 'MPI_Win_lock_all(0,win);'
 395 finEpoch['MPI_Win_lock_all'] = lambda n: 'MPI_Win_unlock_all(win);'
 396
 397 init['MPI_Put'] = lambda n: f'int localbuf{n}[N] = {{12345}};'
 398 operation['MPI_Put'] = lambda n: f'MPI_Put(&localbuf{n}, N, MPI_INT, target, 0, N, type, win);'
 399
 400 init['MPI_Get'] = lambda n: f'int localbuf{n}[N] = {{54321}};'
 401 operation['MPI_Get'] = lambda n: f'MPI_Get(&localbuf{n}, N, MPI_INT, target, 0, N, type, win);'
 402
 403 init['store'] = lambda n: f'int localbuf{n}[N] = {{0}};'
 404 operation['store'] = lambda n: f'localbuf{n}[0] = 8;'
 405
 406 init['rstore'] = lambda n: ""
 407 operation['rstore'] = lambda n: f'winbuf[20] = 12346;'
 408
 409 init['load'] = lambda n: f'int localbuf{n}[N] = {{0}};'
 410 operation['load'] = lambda n: f'int load = localbuf{n}[0];'
 411
 412 init['rload'] = lambda n: ""
 413 operation['rload'] = lambda n: "int load = winbuf[20];"
 414
 415 init['loadstore'] = lambda n: f'int localbuf{n}[N] = {{0}};'
 416 operation['loadstore'] = lambda n: f'if (localbuf{n}[0] % 2 == 0)  localbuf{n}[0]++; '
 417
 418
 419
 420
 421 def find_line(content, target, filename):
 422     res = 1
 423     for line in content.split('\n'):
 424         if re.search(f'[^:]{target}', line):
 425             #print(f'Found {target} at {line}')
 426             return res
 427         res += 1
 428     raise ValueError(f"Line target {target} not found in {filename}.")
 429
 430
 431 def make_file(template, filename, replace):
 432     output = template
 433     filename = filename.replace("_MPI_", "_")
 434     replace['filename'] = filename
 435     # Replace all variables that don't have a ':' in their name
 436     while re.search("@\{[^@:]*\}@", output):
 437         m = re.search("@\{([^@:]*)\}@", output)
 438         target = m.group(1)
 439         #print(f"Replace @{{{target}}}@")
 440         if target in replace.keys():
 441             output = re.sub(f'@\{{{target}\}}@', replace[target], output)
 442             #print(f"Replace {target} -> {replace[target]}")
 443         else:
 444             raise ValueError(f"Variable {target} used in template, but not defined.")
 445     # Now replace all variables with a ':' in their name: line targets are like that, and we don't want to resolve them before the others change the lines
 446     while re.search("@\{([^:@]*):([^@]*)\}@", output):
 447         m = re.search("@\{([^:@]*):([^@]*)\}@", output)
 448         (kind, target) = (m.group(1), m.group(2))
 449         if kind == 'line':
 450             replace = f'{find_line(output, target, filename)}'
 451             #print(f"Replace @{{line:{target}}}@ with '{replace}'")
 452             output = re.sub(f'@\{{line:{target}\}}@', replace, output)
 453         else:
 454             raise ValueError(f"Unknown variable kind: {kind}:{target}")
 455
 456     if os.path.exists(filename):
 457         with open(filename, 'r') as file:
 458             prev = file.read().split('\n')[0]
 459             prev = re.sub('^.*?scripts/', 'scripts/', prev)
 460             prev = re.sub('. DO NOT EDIT.', '', prev)
 461         now = output.split('\n')[0]
 462         now = re.sub('^.*?scripts/', 'scripts/', now)
 463         now = re.sub('. DO NOT EDIT.', '', now)
 464
 465         print(f'WARNING: overwriting {filename}. Previously generated by: {prev}; regenerated by {now}')
 466
 467     # Ready to output it
 468     with open(filename, 'w') as outfile:
 469         outfile.write(output)