Template Function shad::rt::executeAtWithRetBuff(const Locality&, FunT&&, const std::shared_ptr<uint8_t>&, const uint32_t, uint8_t *, uint32_t *)

Function Documentation

template <typename FunT>
void shad::rt::executeAtWithRetBuff(const Locality &loc, FunT &&func, const std::shared_ptr<uint8_t> &argsBuffer, const uint32_t bufferSize, uint8_t *resultBuffer, uint32_t *resultSize)

Execute a function on a selected locality synchronously and return a result buffer.

Typical Usage: 

struct Args {
  int a;
  char b;
};

void task(const uint8_t *src, const uint32_t size,
          const uint8_t *dst, uint32_t * outsize) {
  memcpy(src, dst, size);
  *outsize = size;
}

Args args { 2, 'a' };
/* Args doesn't need a dynamic allocated buffer but
 * more complicated data structure might need it */
std::shared_ptr<uint8_t> ptr(new uint8_t[sizeof(Args)],
                             std::default_delete<uint8_t[]>());
memcpy(ptr.get(), &args, sizeof(Args));

std::unique_ptr<uint8_t[]> outbuff(new uint8_t[sizeof(Args)]);
uint32_t size(0);
for (auto & locality : allLocalities)
  if (static_cast<uint32_t>(locality) % 2)
    // every call will overwrite outbuff
    executeAtWithRetBuff(locality, task, ptr, sizeof(Args),
                         outbuff.get(), &size);

Template Parameters
  • FunT: The type of the function to be executed. The function prototype must be: 
    void(const uint8_t *, const uint32_t, const uint8_t *, uint32_t *);
Parameters
  • loc: The Locality where the function must be executed.
  • func: The function to execute.
  • argsBuffer: A buffer of bytes to be passed to the function.
  • bufferSize: The size of the buffer argsBuffer passed.
  • resultBuffer: The buffer where to store the results.
  • resultSize: The location where the runtime will store the number of bytes written in the result buffer