C++ std::iota方法代碼示例

void RandomPermuter::subset_epoch(
      vector<epoch_op>::iterator &res_start,
      vector<epoch_op>::iterator &res_end,
      epoch &epoch) {

  unsigned int req_size = distance(res_start, res_end);
  assert(req_size <= epoch.ops.size());

  // Even if the number of bios we're placing is less than the number in the
  // epoch, allow any bio but the barrier (if present) to be picked.
  unsigned int slots = epoch.ops.size();
  if (epoch.has_barrier) {
    --slots;
  }

  // Bitmap to indicate which bios in the epoch we want to pick for the crash
  // state.
  vector<unsigned int> epoch_op_bitmap(epoch.ops.size());

  // Fill the list with the empty slots, either [0, epoch.size() - 1] or
  // [0, epoch.size() - 2]. Prefer a list so that removals are fast. We have
  // this so that each time we shuffle the indexes of bios in the epoch, and
  // pick the first req_size number of bios.

  vector<unsigned int> indices(slots);
  iota(indices.begin(), indices.end(), 0);
  // Use a known random generator function for repeatability.
  std::random_shuffle(indices.begin(), indices.end(), subset_random_);

  // Populate the bitmap to set req_set number of bios.
  for (int i = 0; i < req_size; i++) {
    epoch_op_bitmap[indices[i]] = 1;
  }

  // Return the bios corresponding to bitmap indexes.
  for (unsigned int filled = 0;
      filled < epoch_op_bitmap.size() && res_start != res_end; filled++) {
    if (epoch_op_bitmap[filled] == 1) {
      *res_start = epoch.ops.at(filled);
      ++res_start;
    }
  }

  // We are only placing part of an epoch so we need to return here.
  if (res_start == res_end) {
    return;
  }

  assert(epoch.has_barrier);

  // Place the barrier operation if it exists since the entire vector already
  // exists (i.e. we won't cause extra shifting when adding the other elements).
  // Decrement out count of empty slots since we have filled one.
  *res_start = epoch.ops.back();
}

void random_iota(I first, I last) {
  iota(first, last, 0);
  std::random_shuffle(first, last);
}

bool RandomPermuter::gen_one_sector_state(vector<DiskWriteData> &res,
    PermuteTestResult &log_data) {
  res.clear();
  // Return if there are no ops to work with.
  if (GetEpochs()->size() == 0) {
    return false;
  }

  vector<epoch> *epochs = GetEpochs();

  // Pick the point in the sequence we will crash at.
  // Find how many elements we will be returning (randomly determined).
  uniform_int_distribution<unsigned int> permute_epochs(1, epochs->size());
  unsigned int num_epochs = permute_epochs(rand);
  unsigned int num_requests = 0;
  if (!epochs->at(num_epochs - 1).ops.empty()) {
    // It is not valid to call the random number generator with arguments (1, 0)
    // (you get a large number if you do), so skip this if the epoch we crash in
    // has no ops in it.

    // Don't subtract 1 from this size so that we can send a complete epoch if
    // we want.
    uniform_int_distribution<unsigned int> permute_requests(1,
        epochs->at(num_epochs - 1).ops.size());
    num_requests = permute_requests(rand);
  }

  // Tell CrashMonkey the most recently seen checkpoint for the crash state
  // we're generating. We can't just pull the last epoch because it could be the
  // case that there's a checkpoint at the end of this disk write epoch.
  // Therefore, we should determine 1. if we are writing out this entire epoch,
  // and 2. if the checkpoint epoch for this disk write epoch is different than
  // the checkpoint epoch of the disk write epoch before this one (indicating
  // that this disk write epoch changes checkpoint epochs).
  epoch *target = &(epochs->at(num_epochs - 1));
  epoch *prev = NULL;
  if (num_epochs > 1) {
    prev = &epochs->at(num_epochs - 2);
  }
  if (num_requests != target->ops.size()) {
    log_data.last_checkpoint = (prev) ? prev->checkpoint_epoch : 0;
  } else {
    log_data.last_checkpoint = target->checkpoint_epoch;
  }

  // Get and coalesce the sectors of the final epoch we crashed in. We do this
  // here so that we can determine the size of the resulting crash state and
  // allocate that many slots in `res` right off the bat, thus skipping later
  // reallocations as the vector grows.
  vector<EpochOpSector> final_epoch;
  for (unsigned int i = 0; i < num_requests; ++i) {
    vector<EpochOpSector> sectors =
      epochs->at(num_epochs - 1).ops.at(i).ToSectors(sector_size_);
    final_epoch.insert(final_epoch.end(), sectors.begin(), sectors.end());
  }

  unsigned int total_elements = 0;
  for (unsigned int i = 0; i < num_epochs - 1; ++i) {
    total_elements += epochs->at(i).ops.size();
  }

  if (final_epoch.empty()) {
    // No sectors to drop in the final epoch.
    res.resize(total_elements);
    auto epoch_end_iterator = epochs->begin() + num_epochs - 1;
    AddEpochs(res.begin(), res.end(), epochs->begin(), epoch_end_iterator);
    return true;
  } else if (num_requests == epochs->at(num_epochs - 1).ops.size() &&
      epochs->at(num_epochs - 1).ops.back().op.is_barrier()) {
    // We picked the entire epoch and it has a barrier, so we can't rearrange
    // anything.
    res.resize(total_elements + epochs->at(num_epochs - 1).ops.size());
    // + 1 because we also add the full epoch we "crash" in.
    auto epoch_end_iterator = epochs->begin() + num_epochs;
    AddEpochs(res.begin(), res.end(), epochs->begin(), epoch_end_iterator);
    return true;
  }

  // For this branch of execution, we are dropping some sectors from the final
  // epoch we are "crashing" in.

  // Pick a number of sectors to keep. final_epoch.size() > 0 due to if block
  // above, so no need to worry about getting an invalid range.
  uniform_int_distribution<unsigned int> rand_num_sectors(1,
      final_epoch.size());
  const unsigned int num_sectors = rand_num_sectors(rand);

  final_epoch = CoalesceSectors(final_epoch);

  // Result size is now a known quantity.
  res.resize(total_elements + num_sectors);
  // Add the requests not in the final epoch to the result.
  auto epoch_end_iterator = epochs->begin() + (num_epochs - 1);
  auto res_end = res.begin() + total_elements;
  AddEpochs(res.begin(), res_end, epochs->begin(), epoch_end_iterator);

  // Randomly drop some sectors.
  vector<unsigned int> indices(final_epoch.size());
  iota(indices.begin(), indices.end(), 0);
  // Use a known random generator function for repeatability.
//.........這裏部分代碼省略.........

void KDTree::build(const Spheres& spheres)
{
	leaves = 0;
	this->spheres = spheres;
	sceneBBox = createBoundingBox(spheres);

	int axis = static_cast<int>(AXIS_X);

	KDNode root;
	nodes.push_back(root);

	StackNode stackNode;
	stackNode.bbox = sceneBBox;
	stackNode.nodeIdx = nodes.size() - 1;
	stackNode.sphereIndices.resize(spheres.count);
	iota(stackNode.sphereIndices.begin(), stackNode.sphereIndices.end(), 0);

	stack<StackNode> st;
	st.push(stackNode);

	while(!st.empty())
	{
		StackNode stackNode = st.top();
		st.pop();

		if(stackNode.sphereIndices.size() <= maxSpheresInLeaf || nodes.size() >= maxNodes)
		{
			leavesChildren.push_back(stackNode.sphereIndices);
			initLeafNode(stackNode.nodeIdx, leavesChildren.size() - 1);
			++leaves;
			continue;
		}

		axis = axis % 3;
		float leftLimit = stackNode.bbox.vmin[axis];
		float rightLimit = stackNode.bbox.vmax[axis];

		float splitPos = (leftLimit + rightLimit) * 0.5f; // TODO use SAH

		Axis splitAxis = static_cast<Axis>(axis);

		StackNode child1StackNode, child2StackNode;
		nodes.push_back(KDNode());
		child1StackNode.nodeIdx = nodes.size() - 1;
		nodes.push_back(KDNode());
		child2StackNode.nodeIdx = nodes.size() - 1;

		stackNode.bbox.split(splitAxis, splitPos, child1StackNode.bbox, child2StackNode.bbox);

		for(int i = 0; i < stackNode.sphereIndices.size(); ++i)
		{
			if(spheres.centerCoords[axis][stackNode.sphereIndices[i]] < splitPos)
			{
				child1StackNode.sphereIndices.push_back(stackNode.sphereIndices[i]);
			}
			else
			{
				child2StackNode.sphereIndices.push_back(stackNode.sphereIndices[i]);
			}
		}
		initInnerNode(stackNode.nodeIdx, splitAxis, splitPos, child1StackNode.nodeIdx);
		st.push(child2StackNode);
		st.push(child1StackNode);

		axis += 1;
	}
}