Surprising additional communication happens with tuples versus varargs

[jabraham17]

while working with tuples and varargs, I found some surprising communication. My intuition would be that they are handled more or less the same, but that does not seem to be the case.

The following code has an extra GET

proc foo(args...) {
  for param i in 0..#args.size {
    on Locales[1] do
      const s = args[i].localize(); // 1 get for localize
  }
}
proc bar(args) {
  for param i in 0..#args.size {
    on Locales[1] do
      const s = args[i].localize(); // 2 gets: 1 for localize, 1 for ????
  }
}
proc callme(param useBar, args...) {
  if useBar then
    bar(args);
  else
    foo((...args));
}


use CommDiagnostics;
config const verboseComm = false;

if verboseComm then startVerboseComm();
else {
  resetCommDiagnostics();
  startCommDiagnostics();
}
callme(true, "hi", "there");
if verboseComm then stopVerboseComm();
else {
  stopCommDiagnostics();
  printCommDiagnosticsTable();
}

if verboseComm then startVerboseComm();
else {
  resetCommDiagnostics();
  startCommDiagnostics();
}
callme(false, "hi", "there");
if verboseComm then stopVerboseComm();
else {
  stopCommDiagnostics();
  printCommDiagnosticsTable();
}

After discussing with @bradcray and @e-kayrakli, here is what we think is happening.

• The varargs to foo are being stamped out at resolution foo(_e0_arg, _e1_arg), while bar still has a tuple
• During RVF (remote value forwarding), the individual args for foo get forwarded, while tuple for bar does not.

In general, while this is surprising, its not too concerning. But I am capturing it here so if someone ever hits it we have a record of it.