wbtiger
/
foundationdb
mirror of https://github.com/apple/foundationdb.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
foundationdb/fdbserver/workloads/RandomSelector.actor.cpp

525 lines
21 KiB
C++
Raw Normal View History

Initial repository commit
2017-05-26 04:48:44 +08:00
/*
* RandomSelector.actor.cpp
*
* This source file is part of the FoundationDB open source project
*
* Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
remove trailing whitespace from our copyright headers ; fixed formatting of python setup.py
2018-02-22 02:25:11 +08:00
*
Initial repository commit
2017-05-26 04:48:44 +08:00
* 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
remove trailing whitespace from our copyright headers ; fixed formatting of python setup.py
2018-02-22 02:25:11 +08:00
*
Initial repository commit
2017-05-26 04:48:44 +08:00
* http://www.apache.org/licenses/LICENSE-2.0
remove trailing whitespace from our copyright headers ; fixed formatting of python setup.py
2018-02-22 02:25:11 +08:00
*
Initial repository commit
2017-05-26 04:48:44 +08:00
* 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.
*/
Use proper fwd decl in NativeAPI Also NativeAPI.h -> NativeAPI.actor.h
2019-02-18 07:41:16 +08:00
#include "fdbclient/NativeAPI.actor.h"
Use correct fwd decls in TesterInterface Also TesterInterface.h -> TesterInterface.actor.h
2019-02-18 11:25:16 +08:00
#include "fdbserver/TesterInterface.actor.h"
Initial repository commit
2017-05-26 04:48:44 +08:00
#include "fdbclient/ReadYourWrites.h"
Use fwd decls in workloads Also workloads.h -> workloads.actor.h
2019-02-18 11:18:30 +08:00
#include "fdbserver/workloads/workloads.actor.h"
Rewrite all files to have #include actorcompiler.h as the last include.
2018-08-11 06:18:24 +08:00
#include "flow/actorcompiler.h" // This must be the last #include.
Initial repository commit
2017-05-26 04:48:44 +08:00
struct RandomSelectorWorkload : TestWorkload {
int minOperationsPerTransaction,maxOperationsPerTransaction,maxKeySpace,maxOffset,minInitialAmount,maxInitialAmount;
double testDuration;
bool fail;
vector<Future<Void>> clients;
PerfIntCounter transactions, retries;
RandomSelectorWorkload(WorkloadContext const& wcx)
: TestWorkload(wcx), transactions("Transactions"), retries("Retries") {
minOperationsPerTransaction = getOption( options, LiteralStringRef("minOperationsPerTransaction"), 10 );
maxOperationsPerTransaction = getOption( options, LiteralStringRef("minOperationsPerTransaction"), 50 );
maxKeySpace = getOption( options, LiteralStringRef("maxKeySpace"), 20 );
maxOffset = getOption( options, LiteralStringRef("maxOffset"), 5 );
minInitialAmount = getOption( options, LiteralStringRef("minInitialAmount"), 5 );
maxInitialAmount = getOption( options, LiteralStringRef("maxInitialAmount"), 10 );
testDuration = getOption( options, LiteralStringRef("testDuration"), 10.0 );
fail = false;
}
virtual std::string description() { return "RandomSelector"; }
virtual Future<Void> setup( Database const& cx ) {
return randomSelectorSetup( cx->clone(), this );
}
virtual Future<Void> start( Database const& cx ) {
clients.push_back(
timeout(
randomSelectorClient( cx->clone(), this), testDuration, Void()) );
return delay(testDuration);
}
virtual Future<bool> check( Database const& cx ) {
clients.clear();
return !fail;
}
virtual void getMetrics( vector<PerfMetric>& m ) {
m.push_back( transactions.getMetric() );
m.push_back( retries.getMetric() );
}
ACTOR Future<Void> randomSelectorSetup( Database cx, RandomSelectorWorkload* self ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
state Value myValue = StringRef(format("%d", deterministicRandom()->randomInt( 0, 10000000 ) ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
state Transaction tr(cx);
state std::string clientID;
clientID = format("%08d",self->clientId);
loop {
try {
for(int i = 0; i < self->maxOffset; i++){
tr.set(StringRef(clientID + "a/" + format( "%010d", i ) ),myValue);
tr.set(StringRef(clientID + "c/" + format( "%010d", i ) ),myValue);
tr.set(StringRef(clientID + "e/" + format( "%010d", i ) ),myValue);
}
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
tr.reset();
}
}
return Void();
}
ACTOR Future<Void> randomSelectorClient(
Database cx, RandomSelectorWorkload *self) {
state int i;
state int j;
state std::string clientID;
state std::string myKeyA;
state std::string myKeyB;
state std::string myValue;
state std::string myRandomIDKey;
state bool onEqualA;
state bool onEqualB;
state int offsetA;
state int offsetB;
state int randomLimit;
state int randomByteLimit;
state bool reverse;
state Error error;
clientID = format("%08d",self->clientId);
loop {
state Transaction tr(cx);
loop {
try {
tr.clear(KeyRangeRef(StringRef(clientID + "b/"),StringRef(clientID + "c/")));
tr.clear(KeyRangeRef(StringRef(clientID + "d/"),StringRef(clientID + "e/")));
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
for(i = 0; i < deterministicRandom()->randomInt(self->minInitialAmount,self->maxInitialAmount+1); i++){
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
myValue = format("%d", deterministicRandom()->randomInt( 0, 10000000 ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
tr.set(StringRef(clientID + "b/" + myKeyA),myValue);
tr.set(StringRef(clientID + "d/" + myKeyA),myValue);
//TraceEvent("RYOWInit").detail("Key",myKeyA).detail("Value",myValue);
}
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
}
}
state ReadYourWritesTransaction trRYOW(cx);
try {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
for(i = 0; i < deterministicRandom()->randomInt(self->minOperationsPerTransaction,self->maxOperationsPerTransaction+1); i++) {
j = deterministicRandom()->randomInt(0,16);
Initial repository commit
2017-05-26 04:48:44 +08:00
if( j < 3 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
myValue = format("%d", deterministicRandom()->randomInt( 0, 10000000 ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
//TraceEvent("RYOWset").detail("Key",myKeyA).detail("Value",myValue);
trRYOW.set(StringRef(clientID + "b/" + myKeyA),myValue);
loop {
try {
tr.set(StringRef(clientID + "d/" + myKeyA),myValue);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
}
}
} else if( j < 4 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
//TraceEvent("RYOWclear").detail("Key",myKeyA);
trRYOW.clear(StringRef(clientID + "b/" + myKeyA));
loop {
try {
tr.clear(StringRef(clientID + "d/" + myKeyA));
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
}
}
} else if( j < 5 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
int a = deterministicRandom()->randomInt( 1, self->maxKeySpace+1 );
int b = deterministicRandom()->randomInt( 1, self->maxKeySpace+1 );
Initial repository commit
2017-05-26 04:48:44 +08:00
myKeyA = format( "%010d", std::min(a,b) - 1 );
myKeyB = format( "%010d", std::max(a,b) );
//TraceEvent("RYOWclearRange").detail("KeyA",myKeyA).detail("KeyB",myKeyB);
trRYOW.clear( KeyRangeRef( StringRef(clientID + "b/" + myKeyA), StringRef(clientID + "b/" + myKeyB) ) );
loop {
try {
tr.clear( KeyRangeRef( StringRef(clientID + "d/" + myKeyA), StringRef(clientID + "d/" + myKeyB) ) );
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
}
}
} else if( j < 6 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
state Optional<Value> getTest1;
Optional<Value> getTest = wait(trRYOW.get(StringRef(clientID + "b/" + myKeyA)));
getTest1 = getTest;
loop {
try {
Optional<Value> getTest2 = wait(tr.get(StringRef(clientID + "d/" + myKeyA)));
if( ( getTest1.present() && ( !getTest2.present() || getTest1.get() != getTest2.get() ) ) ||
( !getTest1.present() && getTest2.present() ) ) {
TraceEvent(SevError, "RanSelTestFailure").detail("Reason", "The get results did not match").detail("KeyA",myKeyA).detail("RYOW",getTest1.present() ? printable(getTest1.get()) : "Not Present").detail("Regular",getTest2.present() ? printable(getTest2.get()) : "Not Present");
self->fail = true;
}
tr.reset();
break;
} catch (Error &e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
tr.reset();
}
}
}
else if( j < 7 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
myRandomIDKey = format( "%010d", deterministicRandom()->randomInt(0, 1000000000) );
myValue = format("%d", deterministicRandom()->randomInt( 0, 10000000 ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
//TraceEvent("RYOWadd").detail("Key",myKeyA).detail("Value", "\\x01");
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::AddValue);
loop {
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::AddValue);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
if(error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID+"z/"+myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
else if( j < 8 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
myRandomIDKey = format( "%010d", deterministicRandom()->randomInt(0, 1000000000) );
myValue = format("%d", deterministicRandom()->randomInt( 0, 10000000 ) );
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
//TraceEvent("RYOWappendIfFits").detail("Key",myKeyA).detail("Value", myValue);
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::AppendIfFits);
loop {
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::AppendIfFits);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
break;
} catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
if(error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID+"z/"+myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
else if( j < 9 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
myRandomIDKey = format( "%010d", deterministicRandom()->randomInt(0, 1000000000) );
myValue = format("%d", deterministicRandom()->randomInt( 0, 10000000 ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
//TraceEvent("RYOWand").detail("Key",myKeyA).detail("Value", myValue);
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::And);
loop {
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::And);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
if(error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID+"z/"+myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
else if( j < 10 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
myRandomIDKey = format( "%010d", deterministicRandom()->randomInt(0, 1000000000) );
myValue = format("%d", deterministicRandom()->randomInt( 0, 10000000 ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
//TraceEvent("RYOWor").detail("Key",myKeyA).detail("Value", myValue);
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::Or);
loop {
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::Or);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
if(error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID+"z/"+myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
else if( j < 11 ) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format( "%010d", deterministicRandom()->randomInt( 0, self->maxKeySpace+1 ) );
myRandomIDKey = format( "%010d", deterministicRandom()->randomInt(0, 1000000000) );
myValue = format("%d", deterministicRandom()->randomInt( 0, 10000000 ) );
Initial repository commit
2017-05-26 04:48:44 +08:00
//TraceEvent("RYOWxor").detail("Key",myKeyA).detail("Value", myValue);
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::Xor);
loop {
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::Xor);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
} catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
if(error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID+"z/"+myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
else if (j < 12) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format("%010d", deterministicRandom()->randomInt(0, self->maxKeySpace + 1));
myRandomIDKey = format("%010d", deterministicRandom()->randomInt(0, 1000000000));
myValue = format("%d", deterministicRandom()->randomInt(0, 10000000));
Initial repository commit
2017-05-26 04:48:44 +08:00
//TraceEvent("RYOWmax").detail("Key",myKeyA).detail("Value", myValue);
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::Max);
loop{
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::Max);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait(tr.commit());
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
}
catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait(tr.onError(e));
Initial repository commit
2017-05-26 04:48:44 +08:00
if (error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID + "z/" + myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
else if (j < 13) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format("%010d", deterministicRandom()->randomInt(0, self->maxKeySpace + 1));
myRandomIDKey = format("%010d", deterministicRandom()->randomInt(0, 1000000000));
myValue = format("%d", deterministicRandom()->randomInt(0, 10000000));
Initial repository commit
2017-05-26 04:48:44 +08:00
//TraceEvent("RYOWmin").detail("Key",myKeyA).detail("Value", myValue);
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::Min);
loop{
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::Min);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait(tr.commit());
Initial repository commit
2017-05-26 04:48:44 +08:00
break;
}
catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait(tr.onError(e));
Initial repository commit
2017-05-26 04:48:44 +08:00
if (error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID + "z/" + myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
else if (j < 14) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format("%010d", deterministicRandom()->randomInt(0, self->maxKeySpace + 1));
myRandomIDKey = format("%010d", deterministicRandom()->randomInt(0, 1000000000));
myValue = format("%d", deterministicRandom()->randomInt(0, 10000000));
Addressed Review Comments
2017-10-26 07:42:05 +08:00
//TraceEvent("RYOWbytemin").detail("Key",myKeyA).detail("Value", myValue);
Modified existing behavior of MIN and AND atomic ops. The new behavior results in a 'SET' if the atomic op is performed on a non -existing key. Added new atomic ops ByteMin and ByteMax that does lexicographic comparison of byte strings.
2017-10-11 04:02:22 +08:00
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::ByteMin);
loop{
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::ByteMin);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait(tr.commit());
Modified existing behavior of MIN and AND atomic ops. The new behavior results in a 'SET' if the atomic op is performed on a non -existing key. Added new atomic ops ByteMin and ByteMax that does lexicographic comparison of byte strings.
2017-10-11 04:02:22 +08:00
break;
}
catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait(tr.onError(e));
Modified existing behavior of MIN and AND atomic ops. The new behavior results in a 'SET' if the atomic op is performed on a non -existing key. Added new atomic ops ByteMin and ByteMax that does lexicographic comparison of byte strings.
2017-10-11 04:02:22 +08:00
if (error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID + "z/" + myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
add APPEND_IF_FITS to workload and remove guard ; add command to vexillographer
2018-02-28 06:02:24 +08:00
else if (j < 15) {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
myKeyA = format("%010d", deterministicRandom()->randomInt(0, self->maxKeySpace + 1));
myRandomIDKey = format("%010d", deterministicRandom()->randomInt(0, 1000000000));
myValue = format("%d", deterministicRandom()->randomInt(0, 10000000));
Addressed Review Comments
2017-10-26 07:42:05 +08:00
//TraceEvent("RYOWbytemax").detail("Key",myKeyA).detail("Value", myValue);
Modified existing behavior of MIN and AND atomic ops. The new behavior results in a 'SET' if the atomic op is performed on a non -existing key. Added new atomic ops ByteMin and ByteMax that does lexicographic comparison of byte strings.
2017-10-11 04:02:22 +08:00
trRYOW.atomicOp(StringRef(clientID + "b/" + myKeyA), myValue, MutationRef::ByteMax);
loop{
try {
tr.set(StringRef(clientID + "z/" + myRandomIDKey), StringRef());
tr.atomicOp(StringRef(clientID + "d/" + myKeyA), myValue, MutationRef::ByteMax);
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait(tr.commit());
Modified existing behavior of MIN and AND atomic ops. The new behavior results in a 'SET' if the atomic op is performed on a non -existing key. Added new atomic ops ByteMin and ByteMax that does lexicographic comparison of byte strings.
2017-10-11 04:02:22 +08:00
break;
}
catch (Error& e) {
error = e;
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait(tr.onError(e));
Modified existing behavior of MIN and AND atomic ops. The new behavior results in a 'SET' if the atomic op is performed on a non -existing key. Added new atomic ops ByteMin and ByteMax that does lexicographic comparison of byte strings.
2017-10-11 04:02:22 +08:00
if (error.code() == error_code_commit_unknown_result) {
Optional<Value> thing = wait(tr.get(StringRef(clientID + "z/" + myRandomIDKey)));
if (thing.present()) break;
}
}
}
}
Initial repository commit
2017-05-26 04:48:44 +08:00
else {
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
int a = deterministicRandom()->randomInt( 1, self->maxKeySpace+1 );
int b = deterministicRandom()->randomInt( 1, self->maxKeySpace+1 );
Initial repository commit
2017-05-26 04:48:44 +08:00
myKeyA = format( "%010d", std::min(a,b) - 1 );
myKeyB = format( "%010d", std::max(a,b) );
Replace g_random and g_nondeterministic_random with functions deterministicRandom() and nondeterministicRandom() that return thread_local random number generators. Delete g_debug_random and trace_random. Allow only deterministicRandom() to be seeded, and require it to be seeded from each thread on which it is used.
2019-05-11 05:01:52 +08:00
onEqualA = deterministicRandom()->randomInt( 0, 2 ) != 0;
onEqualB = deterministicRandom()->randomInt( 0, 2 ) != 0;
offsetA = deterministicRandom()->randomInt( -1*self->maxOffset/2, self->maxOffset/2 );
offsetB = deterministicRandom()->randomInt( -1*self->maxOffset/2, self->maxOffset/2 );
randomLimit = deterministicRandom()->randomInt( 0, 2*self->maxOffset+self->maxKeySpace );
randomByteLimit = deterministicRandom()->randomInt( 0, (self->maxOffset+self->maxKeySpace)*512);
reverse = deterministicRandom()->random01() > 0.5 ? false : true;
Initial repository commit
2017-05-26 04:48:44 +08:00
Attempt to normalize trace events: * Detail names now all start with an uppercase character and contain no underscores. Ideally these should be head-first camel case, though that was harder to check. * Type names have the same rules, except they allow one underscore (to support a usage pattern Context_Type). The first character after the underscore is also uppercase. * Use seconds instead of milliseconds in details. Added a check when events are logged in simulation that logs a message to stderr if the first two rules above aren't followed. This probably doesn't address every instance of the above problems, but all of the events I was able to hit in simulation pass the check.
2018-06-09 02:11:08 +08:00
//TraceEvent("RYOWgetRange").detail("KeyA", myKeyA).detail("KeyB", myKeyB).detail("OnEqualA",onEqualA).detail("OnEqualB",onEqualB).detail("OffsetA",offsetA).detail("OffsetB",offsetB).detail("RandomLimit",randomLimit).detail("RandomByteLimit", randomByteLimit).detail("Reverse", reverse);
Initial repository commit
2017-05-26 04:48:44 +08:00
state Standalone<RangeResultRef> getRangeTest1;
Standalone<RangeResultRef> getRangeTest = wait( trRYOW.getRange(KeySelectorRef(StringRef(clientID + "b/" + myKeyA),onEqualA,offsetA),KeySelectorRef(StringRef(clientID + "b/" + myKeyB),onEqualB,offsetB),randomLimit,false,reverse) );
getRangeTest1 = getRangeTest;
loop {
try {
Standalone<RangeResultRef> getRangeTest2 = wait( tr.getRange(KeySelectorRef(StringRef(clientID + "d/" + myKeyA),onEqualA,offsetA),KeySelectorRef(StringRef(clientID + "d/" + myKeyB),onEqualB,offsetB),randomLimit,false,reverse) );
bool fail = false;
if( getRangeTest1.size() != getRangeTest2.size() ) {
Attempt to normalize trace events: * Detail names now all start with an uppercase character and contain no underscores. Ideally these should be head-first camel case, though that was harder to check. * Type names have the same rules, except they allow one underscore (to support a usage pattern Context_Type). The first character after the underscore is also uppercase. * Use seconds instead of milliseconds in details. Added a check when events are logged in simulation that logs a message to stderr if the first two rules above aren't followed. This probably doesn't address every instance of the above problems, but all of the events I was able to hit in simulation pass the check.
2018-06-09 02:11:08 +08:00
TraceEvent(SevError, "RanSelTestFailure").detail("Reason", "The getRange results did not match sizes").detail("Size1", getRangeTest1.size()).detail("Size2",getRangeTest2.size()).detail("Limit",randomLimit).detail("ByteLimit", randomByteLimit).detail("Bytes1", getRangeTest1.expectedSize()).detail("Bytes2", getRangeTest2.expectedSize()).detail("Reverse", reverse);
Initial repository commit
2017-05-26 04:48:44 +08:00
fail = true;
self->fail=true;
}
for(int k = 0; k < std::min(getRangeTest1.size(),getRangeTest2.size()); k++) {
if(getRangeTest1[k].value != getRangeTest2[k].value) {
std::string keyA = printable(getRangeTest1[k].key);
std::string valueA = printable(getRangeTest1[k].value);
std::string keyB = printable(getRangeTest2[k].key);
std::string valueB = printable(getRangeTest2[k].value);
Attempt to normalize trace events: * Detail names now all start with an uppercase character and contain no underscores. Ideally these should be head-first camel case, though that was harder to check. * Type names have the same rules, except they allow one underscore (to support a usage pattern Context_Type). The first character after the underscore is also uppercase. * Use seconds instead of milliseconds in details. Added a check when events are logged in simulation that logs a message to stderr if the first two rules above aren't followed. This probably doesn't address every instance of the above problems, but all of the events I was able to hit in simulation pass the check.
2018-06-09 02:11:08 +08:00
TraceEvent(SevError, "RanSelTestFailure").detail("Reason", "The getRange results did not match contents").detail("KeyA",keyA).detail("ValueA",valueA).detail("KeyB",keyB).detail("ValueB",valueB).detail("Reverse", reverse);
Initial repository commit
2017-05-26 04:48:44 +08:00
fail = true;
self->fail=true;
}
}
if(fail) {
std::string outStr1 = "";
for(int k = 0; k < getRangeTest1.size(); k++) {
outStr1 = outStr1 + printable(getRangeTest1[k].key) + " " + format("%d", getRangeTest1[k].value.size()) + " ";
}
std::string outStr2 = "";
for(int k = 0; k < getRangeTest2.size(); k++) {
outStr2 = outStr2 + printable(getRangeTest2[k].key) + " " + format("%d", getRangeTest2[k].value.size()) + " ";
}
Attempt to normalize trace events: * Detail names now all start with an uppercase character and contain no underscores. Ideally these should be head-first camel case, though that was harder to check. * Type names have the same rules, except they allow one underscore (to support a usage pattern Context_Type). The first character after the underscore is also uppercase. * Use seconds instead of milliseconds in details. Added a check when events are logged in simulation that logs a message to stderr if the first two rules above aren't followed. This probably doesn't address every instance of the above problems, but all of the events I was able to hit in simulation pass the check.
2018-06-09 02:11:08 +08:00
TraceEvent("RanSelTestLog").detail("RYOW",outStr1).detail("Normal",outStr2);
Initial repository commit
2017-05-26 04:48:44 +08:00
}
tr.reset();
break;
} catch (Error &e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( tr.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
}
}
}
}
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( trRYOW.commit() );
Initial repository commit
2017-05-26 04:48:44 +08:00
++self->transactions;
state Transaction finalTransaction(cx);
loop {
try {
state Standalone<RangeResultRef> finalTest1 = wait( finalTransaction.getRange(KeyRangeRef(StringRef(clientID + "b/"),StringRef(clientID + "c/")),self->maxKeySpace ) );
Standalone<RangeResultRef> finalTest2 = wait(finalTransaction.getRange(KeyRangeRef(StringRef(clientID + "d/"),StringRef(clientID + "e/")),self->maxKeySpace ) );
if( finalTest1.size() != finalTest2.size() ) {
TraceEvent(SevError, "RanSelTestFailure").detail("Reason", "The final results did not match sizes");
self->fail=true;
}
for(int k = 0; k < finalTest1.size(); k++)
if(finalTest1[k].value != finalTest2[k].value) {
Attempt to normalize trace events: * Detail names now all start with an uppercase character and contain no underscores. Ideally these should be head-first camel case, though that was harder to check. * Type names have the same rules, except they allow one underscore (to support a usage pattern Context_Type). The first character after the underscore is also uppercase. * Use seconds instead of milliseconds in details. Added a check when events are logged in simulation that logs a message to stderr if the first two rules above aren't followed. This probably doesn't address every instance of the above problems, but all of the events I was able to hit in simulation pass the check.
2018-06-09 02:11:08 +08:00
TraceEvent(SevError, "RanSelTestFailure").detail("Reason", "The final results did not match contents").detail("KeyA",printable(finalTest1[k].key)).detail("ValueA",printable(finalTest1[k].value)).detail("KeyB",printable(finalTest2[k].key)).detail("ValueB",printable(finalTest2[k].value)).detail("Reverse", reverse);
Initial repository commit
2017-05-26 04:48:44 +08:00
self->fail=true;
}
break;
} catch (Error &e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( finalTransaction.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
}
}
} catch (Error& e) {
Rewrite all `Void _ = wait(...)` -> `wait(...)`. This takes advantage of the new actorcompiler functionality to avoid having duplicate definitions of `Void _` when trying to feed the un-actorompiled source through clang.
2018-08-11 04:57:10 +08:00
wait( trRYOW.onError(e) );
Initial repository commit
2017-05-26 04:48:44 +08:00
++self->retries;
}
}
}
};
WorkloadFactory<RandomSelectorWorkload> RandomSelectorWorkloadFactory("RandomSelector");