1195 lines
30 KiB
C++
1195 lines
30 KiB
C++
/*
|
|
* FlowTests.actor.cpp
|
|
*
|
|
* This source file is part of the FoundationDB open source project
|
|
*
|
|
* Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
// Unit tests for the flow language and libraries
|
|
|
|
#include "flow/actorcompiler.h"
|
|
#include "flow/UnitTest.h"
|
|
#include "flow/DeterministicRandom.h"
|
|
#include "flow/IThreadPool.h"
|
|
#include "fdbrpc.h"
|
|
#include "IAsyncFile.h"
|
|
|
|
void forceLinkFlowTests() {}
|
|
|
|
using std::vector;
|
|
|
|
template <class T, class Func, class ErrFunc, class CallbackType>
|
|
class LambdaCallback : public CallbackType, public FastAllocated<LambdaCallback<T,Func,ErrFunc,CallbackType>> {
|
|
Func func;
|
|
ErrFunc errFunc;
|
|
|
|
virtual void fire(T const& t) { CallbackType::remove(); func(t); delete this; }
|
|
virtual void error(Error e) { CallbackType::remove(); errFunc(e); delete this; }
|
|
|
|
public:
|
|
LambdaCallback(Func&& f, ErrFunc&& e) : func(std::move(f)), errFunc(std::move(e)) {}
|
|
};
|
|
|
|
template <class T, class Func, class ErrFunc>
|
|
void onReady(Future<T>&& f, Func&& func, ErrFunc&& errFunc) {
|
|
if (f.isReady()) {
|
|
if (f.isError())
|
|
errFunc(f.getError());
|
|
else
|
|
func(f.get());
|
|
}
|
|
else
|
|
f.addCallbackAndClear(new LambdaCallback<T, Func, ErrFunc, Callback<T>>(std::move(func), std::move(errFunc)));
|
|
}
|
|
|
|
template <class T, class Func, class ErrFunc>
|
|
void onReady(FutureStream<T>&& f, Func&& func, ErrFunc&& errFunc) {
|
|
if (f.isReady()) {
|
|
if (f.isError())
|
|
errFunc(f.getError());
|
|
else
|
|
func(f.pop());
|
|
}
|
|
else
|
|
f.addCallbackAndClear(new LambdaCallback<T, Func, ErrFunc, SingleCallback<T>>(std::move(func), std::move(errFunc)));
|
|
}
|
|
|
|
ACTOR static void emptyVoidActor() {
|
|
}
|
|
|
|
ACTOR static Future<Void> emptyActor() {
|
|
return Void();
|
|
}
|
|
|
|
ACTOR static void oneWaitVoidActor(Future<Void> f) {
|
|
Void _ = wait(f);
|
|
}
|
|
|
|
ACTOR static Future<Void> oneWaitActor(Future<Void> f) {
|
|
Void _ = wait(f);
|
|
return Void();
|
|
}
|
|
|
|
Future<Void> g_cheese;
|
|
ACTOR static Future<Void> cheeseWaitActor() {
|
|
Void _ = wait(g_cheese);
|
|
return Void();
|
|
}
|
|
|
|
ACTOR static void trivialVoidActor(int* result) {
|
|
*result = 1;
|
|
}
|
|
|
|
ACTOR static Future<int> return42Actor() {
|
|
return 42;
|
|
}
|
|
|
|
ACTOR static void voidWaitActor(Future<int> in, int* result) {
|
|
int i = wait(in);
|
|
*result = i;
|
|
}
|
|
|
|
ACTOR static Future<int> addOneActor(Future<int> in) {
|
|
int i = wait(in);
|
|
return i + 1;
|
|
}
|
|
|
|
ACTOR static Future<Void> chooseTwoActor(Future<Void> f, Future<Void> g) {
|
|
choose{
|
|
when(Void _ = wait(f)) {}
|
|
when(Void _ = wait(g)) {}
|
|
}
|
|
return Void();
|
|
}
|
|
|
|
ACTOR static Future<int> consumeOneActor(FutureStream<int> in) {
|
|
int i = waitNext(in);
|
|
return i;
|
|
}
|
|
|
|
ACTOR static Future<int> sumActor(FutureStream<int> in) {
|
|
state int total = 0;
|
|
try {
|
|
loop{
|
|
int i = waitNext(in);
|
|
total += i;
|
|
}
|
|
}
|
|
catch (Error& e) {
|
|
if (e.code() != error_code_end_of_stream)
|
|
throw;
|
|
}
|
|
return total;
|
|
}
|
|
|
|
ACTOR template <class T> static Future<T> templateActor(T t) {
|
|
return t;
|
|
}
|
|
|
|
static int destroy() { return 666; }
|
|
ACTOR static Future<Void> testHygeine() {
|
|
ASSERT(destroy() == 666); // Should fail to compile if SAV<Void>::destroy() is visible
|
|
return Void();
|
|
}
|
|
|
|
//bool expectActorCount(int x) { return actorCount == x; }
|
|
bool expectActorCount(int) { return true; }
|
|
|
|
struct YieldMockNetwork : INetwork, ReferenceCounted<YieldMockNetwork> {
|
|
int ticks;
|
|
Promise<Void> nextTick;
|
|
int nextYield;
|
|
INetwork* baseNetwork;
|
|
|
|
virtual flowGlobalType global(int id) { return baseNetwork->global(id); }
|
|
virtual void setGlobal(size_t id, flowGlobalType v) { baseNetwork->setGlobal(id, v); return; }
|
|
|
|
YieldMockNetwork() : ticks(0), nextYield(0) {
|
|
baseNetwork = g_network;
|
|
g_network = this;
|
|
}
|
|
~YieldMockNetwork() {
|
|
g_network = baseNetwork;
|
|
}
|
|
|
|
void tick() {
|
|
ticks++;
|
|
Promise<Void> t;
|
|
t.swap(nextTick);
|
|
t.send(Void());
|
|
}
|
|
|
|
virtual Future<class Void> delay(double seconds, int taskID) {
|
|
return nextTick.getFuture();
|
|
}
|
|
|
|
virtual Future<class Void> yield(int taskID) {
|
|
if (check_yield(taskID))
|
|
return delay(0,taskID);
|
|
return Void();
|
|
}
|
|
|
|
virtual bool check_yield(int taskID) {
|
|
if (nextYield > 0) --nextYield;
|
|
return nextYield == 0;
|
|
}
|
|
|
|
// Delegate everything else. TODO: Make a base class NetworkWrapper for delegating everything in INetwork
|
|
virtual int getCurrentTask() { return baseNetwork->getCurrentTask(); }
|
|
virtual void setCurrentTask(int taskID) { baseNetwork->setCurrentTask(taskID); }
|
|
virtual double now() { return baseNetwork->now(); }
|
|
virtual void stop() { return baseNetwork->stop(); }
|
|
virtual bool isSimulated() const { return baseNetwork->isSimulated(); }
|
|
virtual void onMainThread(Promise<Void>&& signal, int taskID) { return baseNetwork->onMainThread(std::move(signal), taskID); }
|
|
virtual THREAD_HANDLE startThread(THREAD_FUNC_RETURN(*func) (void *), void *arg) { return baseNetwork->startThread(func,arg); }
|
|
virtual Future< Reference<class IAsyncFile> > open(std::string filename, int64_t flags, int64_t mode) { return IAsyncFileSystem::filesystem()->open(filename,flags,mode); }
|
|
virtual Future< Void > deleteFile(std::string filename, bool mustBeDurable) { return IAsyncFileSystem::filesystem()->deleteFile(filename,mustBeDurable); }
|
|
virtual void run() { return baseNetwork->run(); }
|
|
virtual void getDiskBytes(std::string const& directory, int64_t& free, int64_t& total) { return baseNetwork->getDiskBytes(directory,free,total); }
|
|
virtual bool isAddressOnThisHost(NetworkAddress const& addr) { return baseNetwork->isAddressOnThisHost(addr); }
|
|
};
|
|
|
|
struct NonserializableThing {};
|
|
ACTOR static Future<NonserializableThing> testNonserializableThing() {
|
|
return NonserializableThing();
|
|
}
|
|
|
|
ACTOR Future<Void> testCancelled(bool *exits, Future<Void> f) {
|
|
try {
|
|
Void _ = wait(Future<Void>(Never()));
|
|
} catch( Error &e ) {
|
|
state Error err = e;
|
|
try {
|
|
Void _ = wait(Future<Void>(Never()));
|
|
} catch( Error &e ) {
|
|
*exits = true;
|
|
throw;
|
|
}
|
|
throw err;
|
|
}
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/cancel1")
|
|
{
|
|
bool exits = false;
|
|
Promise<Void> p;
|
|
Future<Void> test = testCancelled(&exits, p.getFuture());
|
|
ASSERT(p.getPromiseReferenceCount() == 1 && p.getFutureReferenceCount() == 1);
|
|
test.cancel();
|
|
ASSERT(exits);
|
|
ASSERT(test.getPromiseReferenceCount() == 0 && test.getFutureReferenceCount() == 1 && test.isReady() && test.isError() && test.getError().code() == error_code_actor_cancelled);
|
|
ASSERT(p.getPromiseReferenceCount() == 1 && p.getFutureReferenceCount() == 0);
|
|
|
|
|
|
return Void();
|
|
}
|
|
|
|
ACTOR static Future<Void> noteCancel(int* cancelled) {
|
|
*cancelled = 0;
|
|
try {
|
|
Void _ = wait(Future<Void>(Never()));
|
|
throw internal_error();
|
|
}
|
|
catch (...) {
|
|
printf("Cancelled!\n");
|
|
*cancelled = 1;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
TEST_CASE("flow/flow/cancel2")
|
|
{
|
|
int c1 = 0, c2 = 0, c3 = 0;
|
|
|
|
Future<Void> cf = noteCancel(&c1);
|
|
ASSERT(c1 == 0);
|
|
cf = Future<Void>();
|
|
ASSERT(c1 == 1);
|
|
|
|
cf = noteCancel(&c2) && noteCancel(&c3);
|
|
ASSERT(c2 == 0 && c3 == 0);
|
|
cf = Future<Void>();
|
|
ASSERT(c2 == 1 && c3 == 1);
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/nonserializable futures")
|
|
{
|
|
// Types no longer need to be statically serializable to make futures, promises, actors
|
|
{
|
|
Future<NonserializableThing> f = testNonserializableThing();
|
|
Promise<NonserializableThing> p;
|
|
p.send(NonserializableThing());
|
|
f = p.getFuture();
|
|
}
|
|
|
|
// But this won't compile
|
|
//ReplyPromise<NonserializableThing> rp;
|
|
|
|
// ReplyPromise can be used like a normal promise
|
|
{
|
|
ReplyPromise<int> rpInt;
|
|
Future<int> f = rpInt.getFuture();
|
|
ASSERT(!f.isReady());
|
|
rpInt.send(123);
|
|
ASSERT(f.get() == 123);
|
|
}
|
|
|
|
{
|
|
RequestStream<int> rsInt;
|
|
FutureStream<int> f = rsInt.getFuture();
|
|
rsInt.send(1);
|
|
rsInt.send(2);
|
|
ASSERT(f.pop() == 1);
|
|
ASSERT(f.pop() == 2);
|
|
}
|
|
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/networked futures")
|
|
{
|
|
// RequestStream can be serialized
|
|
{
|
|
RequestStream<int> locInt;
|
|
BinaryWriter wr(IncludeVersion());
|
|
wr << locInt;
|
|
|
|
ASSERT(locInt.getEndpoint().isValid() && locInt.getEndpoint().isLocal() && locInt.getEndpoint().address == FlowTransport::transport().getLocalAddress());
|
|
|
|
BinaryReader rd(wr.toStringRef(), IncludeVersion());
|
|
RequestStream<int> remoteInt;
|
|
rd >> remoteInt;
|
|
|
|
ASSERT(remoteInt.getEndpoint() == locInt.getEndpoint());
|
|
}
|
|
|
|
|
|
// ReplyPromise can be serialized
|
|
// TODO: This needs to fiddle with g_currentDeliveryPeerAddress
|
|
if (0) {
|
|
ReplyPromise<int> locInt;
|
|
BinaryWriter wr(IncludeVersion());
|
|
wr << locInt;
|
|
|
|
ASSERT(locInt.getEndpoint().isValid() && locInt.getEndpoint().isLocal());
|
|
|
|
BinaryReader rd(wr.toStringRef(), IncludeVersion());
|
|
ReplyPromise<int> remoteInt;
|
|
rd >> remoteInt;
|
|
|
|
ASSERT(remoteInt.getEndpoint() == locInt.getEndpoint());
|
|
}
|
|
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/quorum")
|
|
{
|
|
vector<Promise<int>> ps(5);
|
|
vector<Future<int>> fs;
|
|
vector<Future<Void>> qs;
|
|
for (auto& p : ps) fs.push_back(p.getFuture());
|
|
|
|
for (int i = 0; i <= ps.size(); i++)
|
|
qs.push_back( quorum(fs, i) );
|
|
|
|
for (int i = 0; i < ps.size(); i++) {
|
|
ASSERT(qs[i].isReady());
|
|
ASSERT(!qs[i + 1].isReady());
|
|
ps[i].send(i);
|
|
}
|
|
ASSERT(qs[ps.size()].isReady());
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/trivial futures")
|
|
{
|
|
Future<int> invalid;
|
|
ASSERT(!invalid.isValid());
|
|
|
|
Future<int> never = Never();
|
|
ASSERT(never.isValid() && !never.isReady());
|
|
|
|
Future<int> one = 1;
|
|
ASSERT(one.isValid() && one.isReady() && !one.isError());
|
|
ASSERT(one.get() == 1);
|
|
ASSERT(one.getFutureReferenceCount() == 1);
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/trivial promises")
|
|
{
|
|
Future<int> f;
|
|
|
|
Promise<int> p;
|
|
ASSERT(p.isValid());
|
|
ASSERT(!p.isSet());
|
|
p.send(1);
|
|
ASSERT(p.isSet());
|
|
ASSERT(p.getFuture().get() == 1);
|
|
|
|
Promise<int> p2;
|
|
f = p2.getFuture();
|
|
ASSERT(f.isValid() && !f.isReady());
|
|
p2.send(2);
|
|
ASSERT(f.isValid() && f.isReady() && !f.isError());
|
|
ASSERT(f.get() == 2);
|
|
|
|
Promise<int> p3;
|
|
f = p3.getFuture();
|
|
p3.sendError(end_of_stream());
|
|
ASSERT(f.isValid() && f.isReady() && f.isError());
|
|
ASSERT(f.getError().code() == error_code_end_of_stream);
|
|
|
|
Promise<int> p4;
|
|
f = p4.getFuture();
|
|
p4 = Promise<int>();
|
|
ASSERT(p4.isValid() && !p4.isSet());
|
|
ASSERT(f.isValid() && f.isReady() && f.isError());
|
|
ASSERT(f.getError().code() == error_code_broken_promise);
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/trivial promisestreams")
|
|
{
|
|
FutureStream<int> f;
|
|
|
|
PromiseStream<int> p;
|
|
p.send(1);
|
|
ASSERT(p.getFuture().isReady());
|
|
ASSERT(p.getFuture().pop() == 1);
|
|
|
|
PromiseStream<int> p2;
|
|
f = p2.getFuture();
|
|
ASSERT(f.isValid() && !f.isReady());
|
|
p2.send(2);
|
|
p2.send(3);
|
|
ASSERT(f.isValid() && f.isReady() && !f.isError());
|
|
ASSERT(f.pop() == 2);
|
|
ASSERT(f.pop() == 3);
|
|
|
|
PromiseStream<int> p3;
|
|
f = p3.getFuture();
|
|
p3.send(4);
|
|
p3.sendError(end_of_stream());
|
|
ASSERT(f.isReady() && !f.isError());
|
|
ASSERT(f.pop() == 4);
|
|
ASSERT(f.isError());
|
|
ASSERT(f.getError().code() == error_code_end_of_stream);
|
|
|
|
PromiseStream<int> p4;
|
|
f = p4.getFuture();
|
|
p4 = PromiseStream<int>();
|
|
ASSERT(f.isValid() && f.isReady() && f.isError());
|
|
ASSERT(f.getError().code() == error_code_broken_promise);
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/callbacks")
|
|
{
|
|
Promise<int> p;
|
|
Future<int> f = p.getFuture();
|
|
int result = 0;
|
|
bool happened = false;
|
|
|
|
onReady(std::move(f), [&result](int x) { result = x; }, [&result](Error e) { result = -1; });
|
|
onReady(p.getFuture(), [&happened](int) { happened = true; }, [&happened](Error){ happened = true; });
|
|
ASSERT(!f.isValid());
|
|
ASSERT(p.isValid() && !p.isSet() && p.getFutureReferenceCount()==1);
|
|
ASSERT(result == 0 && !happened);
|
|
|
|
p.send(123);
|
|
ASSERT(result == 123 && happened);
|
|
ASSERT(p.isValid() && p.isSet() && p.getFutureReferenceCount() == 0 && p.getFuture().get() == 123);
|
|
|
|
result = 0;
|
|
onReady(p.getFuture(), [&result](int x) { result = x; }, [&result](Error e) { result = -1; });
|
|
ASSERT(result == 123);
|
|
ASSERT(p.isValid() && p.isSet() && p.getFutureReferenceCount() == 0 && p.getFuture().get() == 123);
|
|
|
|
p = Promise<int>();
|
|
f = p.getFuture();
|
|
result = 0;
|
|
onReady(std::move(f), [&result](int x) { result = x; }, [&result](Error e) { result = -e.code(); });
|
|
ASSERT(!f.isValid());
|
|
ASSERT(p.isValid() && !p.isSet() && p.getFutureReferenceCount() == 1);
|
|
ASSERT(result == 0);
|
|
|
|
p = Promise<int>();
|
|
ASSERT(result == -error_code_broken_promise);
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/promisestream callbacks")
|
|
{
|
|
PromiseStream<int> p;
|
|
|
|
int result = 0;
|
|
|
|
onReady(p.getFuture(), [&result](int x) { result = x; }, [&result](Error e){ result = -1; });
|
|
|
|
ASSERT(result == 0);
|
|
|
|
p.send(123);
|
|
p.send(456);
|
|
|
|
ASSERT(result == 123);
|
|
result = 0;
|
|
|
|
onReady(p.getFuture(), [&result](int x) { result = x; }, [&result](Error e){ result = -1; });
|
|
|
|
ASSERT(result == 456);
|
|
result = 0;
|
|
|
|
onReady(p.getFuture(), [&result](int x) { result = x; }, [&result](Error e){ result = -1; });
|
|
|
|
ASSERT(result == 0);
|
|
|
|
p = PromiseStream<int>();
|
|
|
|
ASSERT(result == -1);
|
|
return Void();
|
|
}
|
|
|
|
//Incompatible with --crash, so we are commenting it out for now
|
|
/*
|
|
TEST_CASE("flow/flow/promisestream multiple wait error")
|
|
{
|
|
state int result = 0;
|
|
state PromiseStream<int> p;
|
|
try {
|
|
onReady(p.getFuture(), [&result](int x) { result = x; }, [&result](Error e){ result = -1; });
|
|
result = 100;
|
|
onReady(p.getFuture(), [&result](int x) { result = x; }, [&result](Error e){ result = -1; });
|
|
ASSERT(false);
|
|
}
|
|
catch (Error& e) {
|
|
ASSERT(e.code() == error_code_internal_error);
|
|
}
|
|
ASSERT(result == 100);
|
|
p = PromiseStream<int>();
|
|
ASSERT(result == -1);
|
|
return Void();
|
|
}
|
|
*/
|
|
|
|
TEST_CASE("flow/flow/trivial actors")
|
|
{
|
|
ASSERT(expectActorCount(0));
|
|
|
|
int result = 0;
|
|
trivialVoidActor(&result);
|
|
ASSERT(result == 1);
|
|
ASSERT(expectActorCount(0));
|
|
|
|
Future<int> f = return42Actor();
|
|
ASSERT(f.isReady() && !f.isError() && f.get() == 42 && f.getFutureReferenceCount()==1 && f.getPromiseReferenceCount() == 0);
|
|
ASSERT(expectActorCount(1));
|
|
f = Future<int>();
|
|
ASSERT(expectActorCount(0));
|
|
|
|
f = templateActor(24);
|
|
ASSERT(f.isReady() && !f.isError() && f.get() == 24 && f.getFutureReferenceCount() == 1 && f.getPromiseReferenceCount() == 0);
|
|
ASSERT(expectActorCount(1));
|
|
f = Future<int>();
|
|
ASSERT(expectActorCount(0));
|
|
|
|
result = 0;
|
|
voidWaitActor(2, &result);
|
|
ASSERT(result == 2 && expectActorCount(0));
|
|
|
|
Promise<int> p;
|
|
f = addOneActor(p.getFuture());
|
|
ASSERT(!f.isReady() && expectActorCount(1));
|
|
p.send(100);
|
|
ASSERT(f.isReady() && f.get() == 101);
|
|
ASSERT(expectActorCount(1)); //< hmm
|
|
f = Future<int>();
|
|
ASSERT(expectActorCount(0));
|
|
|
|
PromiseStream<int> ps;
|
|
f = consumeOneActor(ps.getFuture());
|
|
ASSERT(!f.isReady() && expectActorCount(1));
|
|
ps.send(101);
|
|
ASSERT(f.get() == 101 && ps.isEmpty());
|
|
ps.send(102);
|
|
ASSERT(!ps.isEmpty());
|
|
f = consumeOneActor(ps.getFuture());
|
|
ASSERT(f.get() == 102 && ps.isEmpty());
|
|
|
|
f = sumActor(ps.getFuture());
|
|
ps.send(1);
|
|
ps.send(10);
|
|
ps.send(100);
|
|
ps.sendError(end_of_stream());
|
|
ASSERT(f.get() == 111);
|
|
|
|
ASSERT( testHygeine().isReady() );
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/yieldedFuture/progress")
|
|
{
|
|
// Check that if check_yield always returns true, the yieldedFuture will do nothing immediately but will
|
|
// get one thing done per "tick" (per delay(0) returning).
|
|
|
|
Reference<YieldMockNetwork> yn( new YieldMockNetwork );
|
|
|
|
yn->nextYield = 0;
|
|
|
|
Promise<Void> p;
|
|
Future<Void> u = p.getFuture();
|
|
Future<Void> i = success(u);
|
|
|
|
std::vector<Future<Void>> v;
|
|
for(int i=0; i<5; i++)
|
|
v.push_back(yieldedFuture(u));
|
|
auto numReady = [&v]() {
|
|
return std::count_if(v.begin(), v.end(), [](Future<Void> v) { return v.isReady(); });
|
|
};
|
|
|
|
ASSERT( numReady()==0 );
|
|
p.send(Void());
|
|
ASSERT( u.isReady() && i.isReady() && numReady()==0 );
|
|
|
|
for(int i=0; i<5; i++) {
|
|
yn->tick();
|
|
ASSERT( numReady() == i+1 );
|
|
}
|
|
|
|
for(int i=0; i<5; i++) {
|
|
ASSERT( v[i].getPromiseReferenceCount() == 0 && v[i].getFutureReferenceCount() == 1 );
|
|
}
|
|
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/yieldedFuture/random")
|
|
{
|
|
// Check expectations about exactly how yieldedFuture responds to check_yield results
|
|
|
|
Reference<YieldMockNetwork> yn( new YieldMockNetwork );
|
|
|
|
for(int r=0; r<100; r++) {
|
|
Promise<Void> p;
|
|
Future<Void> u = p.getFuture();
|
|
Future<Void> i = success(u);
|
|
|
|
std::vector<Future<Void>> v;
|
|
for(int i=0; i<25; i++)
|
|
v.push_back(yieldedFuture(u));
|
|
auto numReady = [&v]() {
|
|
return std::count_if(v.begin(), v.end(), [](Future<Void> v) { return v.isReady(); });
|
|
};
|
|
|
|
Future<Void> j = success(u);
|
|
|
|
ASSERT( numReady()==0 );
|
|
|
|
int expectYield = g_random->randomInt(0, 4);
|
|
int expectReady = expectYield;
|
|
yn->nextYield = 1 + expectYield;
|
|
|
|
p.send(Void());
|
|
ASSERT( u.isReady() && i.isReady() && j.isReady() && numReady()==expectReady );
|
|
|
|
while (numReady() != v.size()) {
|
|
expectYield = g_random->randomInt(0, 4);
|
|
yn->nextYield = 1 + expectYield;
|
|
expectReady += 1 + expectYield;
|
|
yn->tick();
|
|
//printf("Yielding %d times, expect %d/%d ready, got %d\n", expectYield, expectReady, v.size(), numReady() );
|
|
ASSERT( numReady() == std::min<int>(expectReady, v.size()) );
|
|
}
|
|
|
|
for(int i=0; i<v.size(); i++) {
|
|
ASSERT( v[i].getPromiseReferenceCount() == 0 && v[i].getFutureReferenceCount() == 1 );
|
|
}
|
|
}
|
|
|
|
return Void();
|
|
}
|
|
|
|
|
|
TEST_CASE("flow/perf/yieldedFuture")
|
|
{
|
|
double start;
|
|
int N = 1000000;
|
|
|
|
Reference<YieldMockNetwork> yn( new YieldMockNetwork );
|
|
|
|
yn->nextYield = 2*N + 100;
|
|
|
|
Promise<Void> p;
|
|
Future<Void> f = p.getFuture();
|
|
vector<Future<Void>> ys;
|
|
|
|
start = timer();
|
|
for (int i = 0; i < N; i++)
|
|
ys.push_back(yieldedFuture(f));
|
|
printf("yieldedFuture(f) create: %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
p.send(Void());
|
|
printf("yieldedFuture(f) total: %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
|
|
for (auto& y : ys)
|
|
ASSERT(y.isReady());
|
|
|
|
p = Promise<Void>();
|
|
f = p.getFuture();
|
|
|
|
start = timer();
|
|
for (int i = 0; i < N; i++)
|
|
yieldedFuture(f);
|
|
printf("yieldedFuture(f) cancel: %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/chooseTwoActor")
|
|
{
|
|
ASSERT(expectActorCount(0));
|
|
|
|
Promise<Void> a, b;
|
|
Future<Void> c = chooseTwoActor(a.getFuture(), b.getFuture());
|
|
ASSERT(a.getFutureReferenceCount()==2 && b.getFutureReferenceCount()==2 && !c.isReady());
|
|
b.send(Void());
|
|
ASSERT(a.getFutureReferenceCount() == 0 && b.getFutureReferenceCount() == 0 && c.isReady() && !c.isError() && expectActorCount(1));
|
|
c = Future<Void>();
|
|
ASSERT(a.getFutureReferenceCount() == 0 && b.getFutureReferenceCount() == 0 && expectActorCount(0));
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/perf/actor patterns")
|
|
{
|
|
double start;
|
|
int N = 1000000;
|
|
|
|
ASSERT(expectActorCount(0));
|
|
|
|
start = timer();
|
|
for (int i = 0; i < N; i++)
|
|
emptyVoidActor();
|
|
printf("emptyVoidActor(): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
|
|
ASSERT(expectActorCount(0));
|
|
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
emptyActor();
|
|
}
|
|
printf("emptyActor(): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
|
|
ASSERT(expectActorCount(0));
|
|
|
|
Promise<Void> neverSet;
|
|
Future<Void> never = neverSet.getFuture();
|
|
Future<Void> already = Void();
|
|
|
|
start = timer();
|
|
for (int i = 0; i < N; i++)
|
|
oneWaitVoidActor(already);
|
|
printf("oneWaitVoidActor(already): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
|
|
ASSERT(expectActorCount(0));
|
|
|
|
/*start = timer();
|
|
for (int i = 0; i < N; i++)
|
|
oneWaitVoidActor(never);
|
|
printf("oneWaitVoidActor(never): %0.1f M/sec\n", N / 1e6 / (timer() - start));*/
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Future<Void> f = oneWaitActor(already);
|
|
ASSERT(f.isReady());
|
|
}
|
|
printf("oneWaitActor(already): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Future<Void> f = oneWaitActor(never);
|
|
ASSERT(!f.isReady());
|
|
}
|
|
printf("(cancelled) oneWaitActor(never): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
ASSERT(expectActorCount(0));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Promise<Void> p;
|
|
Future<Void> f = oneWaitActor(p.getFuture());
|
|
p.send(Void());
|
|
ASSERT(f.isReady());
|
|
}
|
|
printf("oneWaitActor(after): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
out[i] = oneWaitActor(pipe[i].getFuture());
|
|
}
|
|
for (int i = 0; i < N; i++) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out[i].isReady());
|
|
}
|
|
printf("oneWaitActor(fifo): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
out[i] = oneWaitActor(pipe[i].getFuture());
|
|
}
|
|
for (int i = N - 1; i >= 0; i--) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out[i].isReady());
|
|
}
|
|
printf("oneWaitActor(lifo): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Future<Void> f = chooseTwoActor(already, already);
|
|
ASSERT(f.isReady());
|
|
}
|
|
printf("chooseTwoActor(already, already): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Future<Void> f = chooseTwoActor(already, never);
|
|
ASSERT(f.isReady());
|
|
}
|
|
printf("chooseTwoActor(already, never): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Future<Void> f = chooseTwoActor(never, already);
|
|
ASSERT(f.isReady());
|
|
}
|
|
printf("chooseTwoActor(never, already): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Future<Void> f = chooseTwoActor(never, never);
|
|
ASSERT(!f.isReady());
|
|
}
|
|
//ASSERT(expectActorCount(0));
|
|
printf("(cancelled) chooseTwoActor(never, never): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Promise<Void> p;
|
|
Future<Void> f = chooseTwoActor(p.getFuture(), never);
|
|
p.send(Void());
|
|
ASSERT(f.isReady());
|
|
}
|
|
printf("chooseTwoActor(after, never): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
out[i] = chooseTwoActor(pipe[i].getFuture(), never);
|
|
}
|
|
for (int i = 0; i < N; i++) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out[i].isReady());
|
|
}
|
|
printf("chooseTwoActor(fifo, never): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
out[i] = chooseTwoActor(pipe[i].getFuture(), pipe[i].getFuture());
|
|
}
|
|
for (int i = 0; i < N; i++) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out[i].isReady());
|
|
}
|
|
printf("chooseTwoActor(fifo, fifo): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
out[i] = chooseTwoActor(chooseTwoActor(pipe[i].getFuture(), never), never);
|
|
}
|
|
for (int i = 0; i < N; i++) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out[i].isReady());
|
|
}
|
|
printf("chooseTwoActor^2((fifo, never), never): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Promise<Void> p;
|
|
Future<Void> f = oneWaitActor(chooseTwoActor(p.getFuture(), never));
|
|
p.send(Void());
|
|
ASSERT(f.isReady());
|
|
}
|
|
printf("oneWaitActor(chooseTwoActor(after, never)): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
out[i] = oneWaitActor(chooseTwoActor(pipe[i].getFuture(), never));
|
|
}
|
|
for (int i = 0; i < N; i++) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out[i].isReady());
|
|
}
|
|
printf("oneWaitActor(chooseTwoActor(fifo, never)): %0.1f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Promise<Void> p;
|
|
Future<Void> f = chooseTwoActor(p.getFuture(), never);
|
|
Future<Void> a = oneWaitActor(f);
|
|
Future<Void> b = oneWaitActor(f);
|
|
p.send(Void());
|
|
ASSERT(f.isReady());
|
|
}
|
|
printf("2xoneWaitActor(chooseTwoActor(after, never)): %0.2f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out1(N);
|
|
vector<Future<Void>> out2(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Future<Void> f = chooseTwoActor(pipe[i].getFuture(), never);
|
|
out1[i] = oneWaitActor(f);
|
|
out2[i] = oneWaitActor(f);
|
|
}
|
|
for (int i = 0; i < N; i++) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out2[i].isReady());
|
|
}
|
|
printf("2xoneWaitActor(chooseTwoActor(fifo, never)): %0.2f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out1(N);
|
|
vector<Future<Void>> out2(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
Future<Void> f = chooseTwoActor(oneWaitActor(pipe[i].getFuture()), never);
|
|
out1[i] = oneWaitActor(f);
|
|
out2[i] = oneWaitActor(f);
|
|
}
|
|
for (int i = 0; i < N; i++) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out2[i].isReady());
|
|
}
|
|
printf("2xoneWaitActor(chooseTwoActor(oneWaitActor(fifo), never)): %0.2f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
vector<Promise<Void>> pipe(N);
|
|
vector<Future<Void>> out1(N);
|
|
vector<Future<Void>> out2(N);
|
|
start = timer();
|
|
for (int i = 0; i < N; i++) {
|
|
g_cheese = pipe[i].getFuture();
|
|
Future<Void> f = chooseTwoActor(cheeseWaitActor(), never);
|
|
g_cheese = f;
|
|
out1[i] = cheeseWaitActor();
|
|
out2[i] = cheeseWaitActor();
|
|
}
|
|
for (int i = 0; i < N; i++) {
|
|
pipe[i].send(Void());
|
|
ASSERT(out2[i].isReady());
|
|
}
|
|
printf("2xcheeseActor(chooseTwoActor(cheeseActor(fifo), never)): %0.2f M/sec\n", N / 1e6 / (timer() - start));
|
|
printf("sizeof(CheeseWaitActorActor) == %zu\n", sizeof(CheeseWaitActorActor));
|
|
}
|
|
|
|
{
|
|
PromiseStream<int> data;
|
|
start = timer();
|
|
Future<int> sum = sumActor(data.getFuture());
|
|
for (int i = 0; i < N; i++)
|
|
data.send(1);
|
|
data.sendError(end_of_stream());
|
|
ASSERT(sum.get() == N);
|
|
printf("sumActor: %0.2f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
{
|
|
start = timer();
|
|
vector<Promise<Void>> ps(3);
|
|
vector<Future<Void>> fs(3);
|
|
|
|
for (int i = 0; i < N; i++) {
|
|
ps.clear();
|
|
ps.resize(3);
|
|
for (int j = 0; j < ps.size(); j++)
|
|
fs[j] = ps[j].getFuture();
|
|
|
|
Future<Void> q = quorum(fs, 2);
|
|
for (auto& p : ps) p.send(Void());
|
|
}
|
|
printf("quorum(2/3): %0.2f M/sec\n", N / 1e6 / (timer() - start));
|
|
}
|
|
|
|
return Void();
|
|
}
|
|
|
|
template <class YAM>
|
|
struct YAMRandom {
|
|
YAM yam;
|
|
std::vector<Future<Void>> onchanges;
|
|
int kmax;
|
|
|
|
YAMRandom() : kmax(3) {}
|
|
|
|
void randomOp() {
|
|
if (g_random->random01() < 0.01)
|
|
while (!check_yield());
|
|
|
|
int k = g_random->randomInt(0, kmax);
|
|
int op = g_random->randomInt(0, 7);
|
|
//printf("%d",op);
|
|
if (op == 0) {
|
|
onchanges.push_back(yam.onChange(k));
|
|
} else if (op == 1) {
|
|
onchanges.push_back( trigger([this](){ this->randomOp(); }, yam.onChange(k)) );
|
|
} else if (op == 2) {
|
|
if (onchanges.size()) {
|
|
int i = g_random->randomInt(0, onchanges.size());
|
|
onchanges[i] = onchanges.back();
|
|
onchanges.pop_back();
|
|
}
|
|
} else if (op == 3) {
|
|
onchanges.clear();
|
|
} else if (op == 4) {
|
|
int v = g_random->randomInt(0, 3);
|
|
yam.set(k, v);
|
|
} else if (op == 5) {
|
|
yam.trigger(k);
|
|
} else if (op == 6) {
|
|
int a = g_random->randomInt(0, kmax);
|
|
int b = g_random->randomInt(0, kmax);
|
|
yam.triggerRange(std::min(a,b), std::max(a,b)+1);
|
|
}
|
|
}
|
|
};
|
|
|
|
TEST_CASE("flow/flow/YieldedAsyncMap/randomized")
|
|
{
|
|
state YAMRandom<YieldedAsyncMap<int, int>> yamr;
|
|
state int it;
|
|
for (it = 0; it < 100000; it++) {
|
|
yamr.randomOp();
|
|
Void _ = wait(yield());
|
|
}
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/AsyncMap/randomized")
|
|
{
|
|
state YAMRandom<AsyncMap<int, int>> yamr;
|
|
state int it;
|
|
for (it = 0; it < 100000; it++) {
|
|
yamr.randomOp();
|
|
Void _ = wait(yield());
|
|
}
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/YieldedAsyncMap/basic")
|
|
{
|
|
state YieldedAsyncMap<int, int> yam;
|
|
state Future<Void> y0 = yam.onChange(1);
|
|
yam.setUnconditional(1, 0);
|
|
state Future<Void> y1 = yam.onChange(1);
|
|
state Future<Void> y1a = yam.onChange(1);
|
|
state Future<Void> y1b = yam.onChange(1);
|
|
yam.set(1, 1);
|
|
//while (!check_yield()) {}
|
|
//yam.triggerRange(0, 4);
|
|
|
|
state Future<Void> y2 = yam.onChange(1);
|
|
Void _ = wait(reportErrors(y0, "y0"));
|
|
Void _ = wait(reportErrors(y1, "y1"));
|
|
Void _ = wait(reportErrors(y1a, "y1a"));
|
|
Void _ = wait(reportErrors(y1b, "y1b"));
|
|
Void _ = wait(reportErrors(timeout(y2, 5, Void()), "y2"));
|
|
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/YieldedAsyncMap/cancel")
|
|
{
|
|
state YieldedAsyncMap<int, int> yam;
|
|
//ASSERT(yam.count(1) == 0);
|
|
//state Future<Void> y0 = yam.onChange(1);
|
|
//ASSERT(yam.count(1) == 1);
|
|
//yam.setUnconditional(1, 0);
|
|
|
|
ASSERT(yam.count(1) == 0);
|
|
state Future<Void> y1 = yam.onChange(1);
|
|
state Future<Void> y1a = yam.onChange(1);
|
|
state Future<Void> y1b = yam.onChange(1);
|
|
ASSERT(yam.count(1) == 1);
|
|
y1.cancel();
|
|
ASSERT(!y1a.isReady());
|
|
y1a.cancel();
|
|
ASSERT(!y1b.isReady());
|
|
ASSERT(yam.count(1) == 1);
|
|
y1b.cancel();
|
|
ASSERT(y1b.getError().code() == error_code_actor_cancelled);
|
|
ASSERT(yam.count(1) == 0);
|
|
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/YieldedAsyncMap/cancel2")
|
|
{
|
|
state YieldedAsyncMap<int, int> yam;
|
|
|
|
state Future<Void> y1 = yam.onChange(1);
|
|
state Future<Void> y2 = yam.onChange(2);
|
|
|
|
auto* pyam = &yam;
|
|
uncancellable(trigger(
|
|
[pyam](){
|
|
printf("Triggered\n");
|
|
pyam->triggerAll();
|
|
},
|
|
delay(1)));
|
|
|
|
Void _ = wait(y1);
|
|
printf("Got y1\n");
|
|
y2.cancel();
|
|
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("flow/flow/AsyncVar/basic")
|
|
{
|
|
AsyncVar<int> av;
|
|
Future<Void> ch = av.onChange();
|
|
ASSERT(!ch.isReady());
|
|
av.set(5);
|
|
ASSERT(ch.isReady());
|
|
ASSERT(av.get() == 5);
|
|
|
|
ch = av.onChange();
|
|
ASSERT(!ch.isReady());
|
|
av.set(6);
|
|
ASSERT(ch.isReady());
|
|
ASSERT(av.get() == 6);
|
|
|
|
return Void();
|
|
}
|
|
|
|
ACTOR static Future<Void> waitAfterCancel( int* output ) {
|
|
*output = 0;
|
|
try {
|
|
Void _ = wait( Never() );
|
|
} catch (...) {
|
|
Void _ = wait( (*output=1, Future<Void>(Void())) );
|
|
}
|
|
ASSERT(false);
|
|
return Void();
|
|
}
|
|
|
|
TEST_CASE("fdbrpc/flow/wait_expression_after_cancel")
|
|
{
|
|
int a = -1;
|
|
Future<Void> f = waitAfterCancel(&a);
|
|
ASSERT( a == 0 );
|
|
f.cancel();
|
|
ASSERT( a == 1 );
|
|
return Void();
|
|
}
|