AsyncIOTest.cpp File Reference

#include <folly/experimental/io/AsyncIO.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <cstdio>
#include <cstdlib>
#include <memory>
#include <random>
#include <thread>
#include <vector>
#include <glog/logging.h>
#include <folly/ScopeGuard.h>
#include <folly/String.h>
#include <folly/experimental/io/FsUtil.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Sockets.h>

Go to the source code of this file.

Functions
	TEST (AsyncIO, ZeroAsyncDataNotPollable)
	TEST (AsyncIO, ZeroAsyncDataPollable)
	TEST (AsyncIO, SingleAsyncDataNotPollable)
	TEST (AsyncIO, SingleAsyncDataPollable)
	TEST (AsyncIO, MultipleAsyncDataNotPollable)
	TEST (AsyncIO, MultipleAsyncDataPollable)
	TEST (AsyncIO, ManyAsyncDataNotPollable)
	TEST (AsyncIO, ManyAsyncDataPollable)
	TEST (AsyncIO, NonBlockingWait)
	TEST (AsyncIO, Cancel)

Function Documentation

TEST	(	AsyncIO	,
		ZeroAsyncDataNotPollable
	)

Definition at line 290 of file AsyncIOTest.cpp.

                                        {
  testReads({{0, 0}}, AsyncIO::NOT_POLLABLE);
}

TEST	(	AsyncIO	,
		ZeroAsyncDataPollable
	)

Definition at line 294 of file AsyncIOTest.cpp.

                                     {
  testReads({{0, 0}}, AsyncIO::POLLABLE);
}

TEST	(	AsyncIO	,
		SingleAsyncDataNotPollable
	)

Definition at line 298 of file AsyncIOTest.cpp.

                                          {
  testReads({{0, kAlign}}, AsyncIO::NOT_POLLABLE);
  testReads({{0, kAlign}}, AsyncIO::NOT_POLLABLE);
}

TEST	(	AsyncIO	,
		SingleAsyncDataPollable
	)

Definition at line 303 of file AsyncIOTest.cpp.

                                       {
  testReads({{0, kAlign}}, AsyncIO::POLLABLE);
  testReads({{0, kAlign}}, AsyncIO::POLLABLE);
}

TEST	(	AsyncIO	,
		MultipleAsyncDataNotPollable
	)

Definition at line 308 of file AsyncIOTest.cpp.

                                            {
  testReads(
      {{kAlign, 2 * kAlign}, {kAlign, 2 * kAlign}, {kAlign, 4 * kAlign}},
      AsyncIO::NOT_POLLABLE);
  testReads(
      {{kAlign, 2 * kAlign}, {kAlign, 2 * kAlign}, {kAlign, 4 * kAlign}},
      AsyncIO::NOT_POLLABLE);

  testReads(
      {{0, 5 * 1024 * 1024}, {kAlign, 5 * 1024 * 1024}}, AsyncIO::NOT_POLLABLE);

  testReads(
      {
          {kAlign, 0},
          {kAlign, kAlign},
          {kAlign, 2 * kAlign},
          {kAlign, 20 * kAlign},
          {kAlign, 1024 * 1024},
      },
      AsyncIO::NOT_POLLABLE);
}

TEST	(	AsyncIO	,
		MultipleAsyncDataPollable
	)

Definition at line 330 of file AsyncIOTest.cpp.

                                         {
  testReads(
      {{kAlign, 2 * kAlign}, {kAlign, 2 * kAlign}, {kAlign, 4 * kAlign}},
      AsyncIO::POLLABLE);
  testReads(
      {{kAlign, 2 * kAlign}, {kAlign, 2 * kAlign}, {kAlign, 4 * kAlign}},
      AsyncIO::POLLABLE);

  testReads(
      {{0, 5 * 1024 * 1024}, {kAlign, 5 * 1024 * 1024}}, AsyncIO::NOT_POLLABLE);

  testReads(
      {
          {kAlign, 0},
          {kAlign, kAlign},
          {kAlign, 2 * kAlign},
          {kAlign, 20 * kAlign},
          {kAlign, 1024 * 1024},
      },
      AsyncIO::NOT_POLLABLE);
}

TEST	(	AsyncIO	,
		ManyAsyncDataNotPollable
	)

Definition at line 352 of file AsyncIOTest.cpp.

References i, and v.

                                        {
  {
    std::vector<TestSpec> v;
    for (int i = 0; i < 1000; i++) {
      v.push_back({off_t(kAlign * i), kAlign});
    }
    testReads(v, AsyncIO::NOT_POLLABLE);
  }
}

TEST	(	AsyncIO	,
		ManyAsyncDataPollable
	)

Definition at line 362 of file AsyncIOTest.cpp.

References i, and v.

                                     {
  {
    std::vector<TestSpec> v;
    for (int i = 0; i < 1000; i++) {
      v.push_back({off_t(kAlign * i), kAlign});
    }
    testReads(v, AsyncIO::POLLABLE);
  }
}

TEST	(	AsyncIO	,
		NonBlockingWait
	)

Definition at line 372 of file AsyncIOTest.cpp.

References folly::netops::close(), folly::errnoStr(), EXPECT_EQ, EXPECT_LE, EXPECT_TRUE, folly::AsyncIO::pending(), SCOPE_EXIT, folly::size(), folly::AsyncIO::submit(), and folly::AsyncIO::wait().

                               {
  AsyncIO aioReader(1, AsyncIO::NOT_POLLABLE);
  AsyncIO::Op op;
  int fd = ::open(tempFile.path().c_str(), O_DIRECT | O_RDONLY);
  PCHECK(fd != -1);
  SCOPE_EXIT {
    ::close(fd);
  };
  size_t size = 2 * kAlign;
  auto buf = allocateAligned(size);
  op.pread(fd, buf.get(), size, 0);
  aioReader.submit(&op);
  EXPECT_EQ(aioReader.pending(), 1);

  folly::Range<AsyncIO::Op**> completed;
  while (completed.empty()) {
    // poll without blocking until the read request completes.
    completed = aioReader.wait(0);
  }
  EXPECT_EQ(completed.size(), 1);

  EXPECT_TRUE(completed[0] == &op);
  ssize_t res = op.result();
  EXPECT_LE(0, res) << folly::errnoStr(-res);
  EXPECT_EQ(size, res);
  EXPECT_EQ(aioReader.pending(), 0);
}

TEST	(	AsyncIO	,
		Cancel
	)

Definition at line 400 of file AsyncIOTest.cpp.

References folly::AsyncIO::cancel(), folly::netops::close(), EXPECT_EQ, EXPECT_GE, EXPECT_TRUE, i, ops, folly::AsyncIO::pending(), SCOPE_EXIT, folly::size(), folly::AsyncIO::submit(), and folly::AsyncIO::wait().

                      {
  constexpr size_t kNumOpsBatch1 = 10;
  constexpr size_t kNumOpsBatch2 = 10;

  AsyncIO aioReader(kNumOpsBatch1 + kNumOpsBatch2, AsyncIO::NOT_POLLABLE);
  int fd = ::open(tempFile.path().c_str(), O_DIRECT | O_RDONLY);
  PCHECK(fd != -1);
  SCOPE_EXIT {
    ::close(fd);
  };

  size_t completed = 0;

  std::vector<std::unique_ptr<AsyncIO::Op>> ops;
  std::vector<ManagedBuffer> bufs;
  const auto schedule = [&](size_t n) {
    for (size_t i = 0; i < n; ++i) {
      const size_t size = 2 * kAlign;
      bufs.push_back(allocateAligned(size));

      ops.push_back(std::make_unique<AsyncIO::Op>());
      auto& op = *ops.back();

      op.setNotificationCallback([&](AsyncIOOp*) { ++completed; });
      op.pread(fd, bufs.back().get(), size, 0);
      aioReader.submit(&op);
    }
  };

  // Mix completed and canceled operations for this test.
  // In order to achieve that, schedule in two batches and do partial
  // wait() after the first one.

  schedule(kNumOpsBatch1);
  EXPECT_EQ(aioReader.pending(), kNumOpsBatch1);
  EXPECT_EQ(completed, 0);

  auto result = aioReader.wait(1);
  EXPECT_GE(result.size(), 1);
  EXPECT_EQ(completed, result.size());
  EXPECT_EQ(aioReader.pending(), kNumOpsBatch1 - result.size());

  schedule(kNumOpsBatch2);
  EXPECT_EQ(aioReader.pending(), ops.size() - result.size());
  EXPECT_EQ(completed, result.size());

  auto canceled = aioReader.cancel();
  EXPECT_EQ(canceled.size(), ops.size() - result.size());
  EXPECT_EQ(aioReader.pending(), 0);
  EXPECT_EQ(completed, result.size());

  size_t foundCompleted = 0;
  for (auto& op : ops) {
    if (op->state() == AsyncIOOp::State::COMPLETED) {
      ++foundCompleted;
    } else {
      EXPECT_TRUE(op->state() == AsyncIOOp::State::CANCELED) << *op;
    }
  }
  EXPECT_EQ(foundCompleted, completed);
}