Пример #1
0
void extract_kdtree_block(KDTreeBlock*                      b,
                          const diy::Master::ProxyWithLink& cp,
                          diy::Master&                      tess_master)
{
    int tess_lid = tess_master.lid(cp.gid());
    DBlock* d  = (DBlock*) tess_master.block(tess_lid); // assumes all blocks in memory

    // copy out the particles
    d->num_particles = d->num_orig_particles = b->points.size();
    d->particles = (float *)realloc(d->particles, b->points.size() * 3 * sizeof(float));
    for (size_t i = 0; i < d->num_orig_particles; ++i)
    {
        d->particles[3*i + 0] = b->points[i][0];
        d->particles[3*i + 1] = b->points[i][1];
        d->particles[3*i + 2] = b->points[i][2];
    }

    //fprintf(stderr, "[%d]: %d particles copied out\n", cp.gid(), d->num_orig_particles);

    // steal the link
    diy::RegularContinuousLink* tess_link   =
        static_cast<diy::RegularContinuousLink*>(tess_master.link(tess_lid));
    diy::RegularContinuousLink* kdtree_link =
        static_cast<diy::RegularContinuousLink*>(cp.link());
    tess_link->swap(*kdtree_link);

    d->box  = tess_link->bounds();
    for (int i = 0; i < 3; ++i)
    {
        d->bounds.min[i] = tess_link->bounds().min[i];
        d->bounds.max[i] = tess_link->bounds().max[i];
    }

    delete b; // safe to do since kdtree_master doesn't own the blocks (no create/destroy supplied)
}
Пример #2
0
void print_block(Block* b, const diy::Master::ProxyWithLink& cp, bool verbose)
{
  RCLink*  link      = static_cast<RCLink*>(cp.link());

  fmt::print("{}: [{},{},{}] - [{},{},{}] ({} neighbors): {} points\n",
             cp.gid(),
             link->bounds().min[0], link->bounds().min[1], link->bounds().min[2],
             link->bounds().max[0], link->bounds().max[1], link->bounds().max[2],
             link->size(), b->points.size());

  for (int i = 0; i < link->size(); ++i)
  {
      fmt::print("  ({},{},({},{},{})):",
                 link->target(i).gid, link->target(i).proc,
                 link->direction(i)[0],
                 link->direction(i)[1],
                 link->direction(i)[2]);
      const Bounds& bounds = link->bounds(i);
      fmt::print(" [{},{},{}] - [{},{},{}]\n",
                 bounds.min[0], bounds.min[1], bounds.min[2],
                 bounds.max[0], bounds.max[1], bounds.max[2]);
  }

  if (verbose)
    for (size_t i = 0; i < b->points.size(); ++i)
      fmt::print("  {} {} {}\n", b->points[i][0], b->points[i][1], b->points[i][2]);
}
Пример #3
0
void output(void* b_, const diy::Master::ProxyWithLink& cp, void*)
{
  Block*        b = static_cast<Block*>(b_);
  std::cout << cp.gid() << " " << b->average << std::endl;
  for (int i = 0; i < cp.link()->size(); ++i)
    std::cout << "  " << cp.link()->target(i).gid << " " << cp.link()->target(i).proc << std::endl;
}
Пример #4
0
void verify(Block*, const diy::Master::ProxyWithLink& cp)
{
  for (auto in : *cp.incoming())
  {
    std::int64_t recvd_sum;
    std::vector<std::int64_t> buffer;

    cp.dequeue(in.first, buffer);
    cp.dequeue(in.first, recvd_sum);

    std::int64_t comp_sum = 0;
    bool valid_values = true;
    for (int64_t v : buffer)
    {
      if (v < -9 || v > 9)
      {
        valid_values = false;
        break;
      }
      comp_sum += v;
    }
    CHECK(valid_values == true);
    CHECK(recvd_sum == comp_sum);
  }
}
Пример #5
0
void flip_coin(void* b_, const diy::Master::ProxyWithLink& cp, void*)
{
  Block*        b = static_cast<Block*>(b_);

  b->count++;
  bool done = rand() % 2;
  //std::cout << cp.gid() << "  " << done << " " << b->count << std::endl;
  cp.collectives()->clear();
  cp.all_reduce(done, std::logical_and<bool>());
}
 // the rest is optional
 void show_link(const diy::Master::ProxyWithLink& cp)
     {
         diy::RegularLink<Bounds>* link = static_cast<diy::RegularLink<Bounds>*>(cp.link());
         std::cout << "Block (" << cp.gid() << "): "
                   << link->core().min[0]   << ' ' << link->core().min[1]   << ' '
                   << link->core().min[2] << " - "
                   << link->core().max[0]   << ' ' << link->core().max[1]   << ' '
                   << link->core().max[2] << " : "
                   << link->bounds().min[0] << ' ' << link->bounds().min[1] << ' '
                   << link->bounds().min[2] << " - "
                   << link->bounds().max[0] << ' ' << link->bounds().max[1] << ' '
                   << link->bounds().max[2] << " : "
                   << link->size()   << ' ' //<< std::endl
                   << std::dec
                   << std::endl;
     }
Пример #7
0
void local_sum(Block* b, const diy::Master::ProxyWithLink& cp)
{
    std::default_random_engine generator(cp.gid());
    std::uniform_int_distribution<std::int64_t> distribution(-9, 9);

    std::int64_t sum = 0;
    std::vector<std::int64_t> buffer(b->size);
    for (auto &v : buffer)
    {
      v = distribution(generator);
      sum += v;
    }

    diy::Link* l = cp.link();
    for (int i = 0; i < l->size(); ++i)
    {
      cp.enqueue(l->target(i), buffer);
      cp.enqueue(l->target(i), sum);
    }
}
Пример #8
0
void populate_kdtree_block(DBlock*                         d,
                           const diy::Master::ProxyWithLink& cp,
                           diy::Master&                      kdtree_master,
                           bool                              wrap)
{
    diy::ContinuousBounds domain = d->data_bounds;

    KDTreeBlock* b = new KDTreeBlock;
    diy::RegularContinuousLink* l = new diy::RegularContinuousLink(3, domain, domain);
    kdtree_master.add(cp.gid(), b, l);

    // copy the particles over
    b->points.resize(d->num_orig_particles);
    for (size_t i = 0; i < d->num_orig_particles; ++i)
    {
        b->points[i][0] = d->particles[3*i + 0];
        b->points[i][1] = d->particles[3*i + 1];
        b->points[i][2] = d->particles[3*i + 2];
    }
}
Пример #9
0
void min_max(void* b_, const diy::Master::ProxyWithLink& cp, void*)
{
  Block*   b   = static_cast<Block*>(b_);
  cp.all_reduce(b->points.size(), diy::mpi::minimum<size_t>());
  cp.all_reduce(b->points.size(), diy::mpi::maximum<size_t>());
}
Пример #10
0
void verify_block(Block* b, const diy::Master::ProxyWithLink& cp, bool wrap, const Bounds& domain)
{
  RCLink*  link = static_cast<RCLink*>(cp.link());

  for (size_t i = 0; i < b->points.size(); ++i)
    for (unsigned j = 0; j < DIM; ++j)
    {
      INFO("Point " << i << " outside bounds in dimension " << j);
      CHECK(b->points[i][j] >= link->bounds().min[j]);
      CHECK(b->points[i][j] <= link->bounds().max[j]);
    }

  // verify neighbor bounds
  for (int i = 0; i < link->size(); ++i)
  {
      int nbr_gid = link->target(i).gid;
      INFO("Checking that bounds in the link match actual remote block bounds for gid = " << nbr_gid);
      CHECK (link->bounds(i) == b->block_bounds[nbr_gid]);
  }

  // verify wrap
  if (wrap)
      for (int i = 0; i < link->size(); ++i)
      {
          for (unsigned j = 0; j < DIM; ++j)
          {
              if (link->wrap(i)[j] == -1)
              {
                  INFO("Checking wrap matches: " << cp.gid() << " -> " << link->target(i).gid);
                  CHECK(link->bounds().min[j]  == domain.min[j]);
                  CHECK(link->bounds(i).max[j] == domain.max[j]);
              }
              if (link->wrap(i)[j] ==  1)
              {
                  INFO("Checking wrap matches: " << cp.gid() << " -> " << link->target(i).gid);
                  CHECK(link->bounds().max[j]  == domain.max[j]);
                  CHECK(link->bounds(i).min[j] == domain.min[j]);
              }
          }
      }


  // verify that we intersect everybody in the link
  for (int i = 0; i < link->size(); ++i)
      for (unsigned j = 0; j < DIM; ++j)
      {
          INFO("Checking neighbor intersection: " << cp.gid() << " -> " << link->target(i).gid);
          CHECK(intersects(link->bounds(), link->bounds(i), j, wrap, domain));
      }

  // verify that we don't intersect anybody not in the link
  for (int i = 0; i < (int) b->block_bounds.size(); ++i)
  {
      if (i == cp.gid()) continue;
      unsigned j = 0;
      for (; j < DIM; ++j)
      {
          if (!intersects(link->bounds(), b->block_bounds[i], j, wrap, domain))
              break;
      }
      if (j == DIM)     // intersect
      {
          int k = 0;
          for (; k < link->size(); ++k)
          {
              if (link->target(k).gid == i)
                  break;
          }

          INFO("Checking whether we intersect a block not in the link: " << cp.gid() << " -/-> " << i);
          CHECK(k != link->size());
      }
  }
}