pkg/fuzzer: remove signal rotation

Signal rotation is intended to make the fuzzer re-discover flaky coverage
in non flaky way. However, taking into accout that we get effectively
the same effect after each manager restart, and that the fuzzer is overloaded
with triage/smash jobs, it does not look to be worth it.

3 files changed, 7 insertions, 74 deletions

diff --git a/pkg/flatrpc/flatrpc.fbs b/pkg/flatrpc/flatrpc.fbs
index f0b03c4a9..121b289e9 100644
--- a/pkg/flatrpc/flatrpc.fbs
+++ b/pkg/flatrpc/flatrpc.fbs
@@ -164,7 +164,6 @@ table ExecRequestRaw {
 
 table SignalUpdateRaw {
 	new_max			:[uint64];
-	drop_max		:[uint64];
 }
 
 // This message serves as a signal that the corpus was triaged and the fuzzer
diff --git a/pkg/flatrpc/flatrpc.go b/pkg/flatrpc/flatrpc.go
index 87f6ad19d..79c0d6cf2 100644
--- a/pkg/flatrpc/flatrpc.go
+++ b/pkg/flatrpc/flatrpc.go
@@ -2061,8 +2061,7 @@ func ExecRequestRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 }
 
 type SignalUpdateRawT struct {
-	NewMax  []uint64 `json:"new_max"`
-	DropMax []uint64 `json:"drop_max"`
+	NewMax []uint64 `json:"new_max"`
 }
 
 func (t *SignalUpdateRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -2078,18 +2077,8 @@ func (t *SignalUpdateRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse
 		}
 		newMaxOffset = builder.EndVector(newMaxLength)
 	}
-	dropMaxOffset := flatbuffers.UOffsetT(0)
-	if t.DropMax != nil {
-		dropMaxLength := len(t.DropMax)
-		SignalUpdateRawStartDropMaxVector(builder, dropMaxLength)
-		for j := dropMaxLength - 1; j >= 0; j-- {
-			builder.PrependUint64(t.DropMax[j])
-		}
-		dropMaxOffset = builder.EndVector(dropMaxLength)
-	}
 	SignalUpdateRawStart(builder)
 	SignalUpdateRawAddNewMax(builder, newMaxOffset)
-	SignalUpdateRawAddDropMax(builder, dropMaxOffset)
 	return SignalUpdateRawEnd(builder)
 }
 
@@ -2099,11 +2088,6 @@ func (rcv *SignalUpdateRaw) UnPackTo(t *SignalUpdateRawT) {
 	for j := 0; j < newMaxLength; j++ {
 		t.NewMax[j] = rcv.NewMax(j)
 	}
-	dropMaxLength := rcv.DropMaxLength()
-	t.DropMax = make([]uint64, dropMaxLength)
-	for j := 0; j < dropMaxLength; j++ {
-		t.DropMax[j] = rcv.DropMax(j)
-	}
 }
 
 func (rcv *SignalUpdateRaw) UnPack() *SignalUpdateRawT {
@@ -2168,34 +2152,8 @@ func (rcv *SignalUpdateRaw) MutateNewMax(j int, n uint64) bool {
 	return false
 }
 
-func (rcv *SignalUpdateRaw) DropMax(j int) uint64 {
-	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
-	if o != 0 {
-		a := rcv._tab.Vector(o)
-		return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8))
-	}
-	return 0
-}
-
-func (rcv *SignalUpdateRaw) DropMaxLength() int {
-	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
-	if o != 0 {
-		return rcv._tab.VectorLen(o)
-	}
-	return 0
-}
-
-func (rcv *SignalUpdateRaw) MutateDropMax(j int, n uint64) bool {
-	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
-	if o != 0 {
-		a := rcv._tab.Vector(o)
-		return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n)
-	}
-	return false
-}
-
 func SignalUpdateRawStart(builder *flatbuffers.Builder) {
-	builder.StartObject(2)
+	builder.StartObject(1)
 }
 func SignalUpdateRawAddNewMax(builder *flatbuffers.Builder, newMax flatbuffers.UOffsetT) {
 	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(newMax), 0)
@@ -2203,12 +2161,6 @@ func SignalUpdateRawAddNewMax(builder *flatbuffers.Builder, newMax flatbuffers.U
 func SignalUpdateRawStartNewMaxVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
 	return builder.StartVector(8, numElems, 8)
 }
-func SignalUpdateRawAddDropMax(builder *flatbuffers.Builder, dropMax flatbuffers.UOffsetT) {
-	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(dropMax), 0)
-}
-func SignalUpdateRawStartDropMaxVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
-	return builder.StartVector(8, numElems, 8)
-}
 func SignalUpdateRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	return builder.EndObject()
 }
diff --git a/pkg/flatrpc/flatrpc.h b/pkg/flatrpc/flatrpc.h
index a2704f9e9..7ce247d2e 100644
--- a/pkg/flatrpc/flatrpc.h
+++ b/pkg/flatrpc/flatrpc.h
@@ -1778,28 +1778,21 @@ flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(flatbuffers::FlatBuffer
 struct SignalUpdateRawT : public flatbuffers::NativeTable {
   typedef SignalUpdateRaw TableType;
   std::vector<uint64_t> new_max{};
-  std::vector<uint64_t> drop_max{};
 };
 
 struct SignalUpdateRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef SignalUpdateRawT NativeTableType;
   typedef SignalUpdateRawBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_NEW_MAX = 4,
-    VT_DROP_MAX = 6
+    VT_NEW_MAX = 4
   };
   const flatbuffers::Vector<uint64_t> *new_max() const {
     return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_NEW_MAX);
   }
-  const flatbuffers::Vector<uint64_t> *drop_max() const {
-    return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_DROP_MAX);
-  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_NEW_MAX) &&
            verifier.VerifyVector(new_max()) &&
-           VerifyOffset(verifier, VT_DROP_MAX) &&
-           verifier.VerifyVector(drop_max()) &&
            verifier.EndTable();
   }
   SignalUpdateRawT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1814,9 +1807,6 @@ struct SignalUpdateRawBuilder {
   void add_new_max(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> new_max) {
     fbb_.AddOffset(SignalUpdateRaw::VT_NEW_MAX, new_max);
   }
-  void add_drop_max(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> drop_max) {
-    fbb_.AddOffset(SignalUpdateRaw::VT_DROP_MAX, drop_max);
-  }
   explicit SignalUpdateRawBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -1830,24 +1820,19 @@ struct SignalUpdateRawBuilder {
 
 inline flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw(
     flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<uint64_t>> new_max = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint64_t>> drop_max = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<uint64_t>> new_max = 0) {
   SignalUpdateRawBuilder builder_(_fbb);
-  builder_.add_drop_max(drop_max);
   builder_.add_new_max(new_max);
   return builder_.Finish();
 }
 
 inline flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRawDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<uint64_t> *new_max = nullptr,
-    const std::vector<uint64_t> *drop_max = nullptr) {
+    const std::vector<uint64_t> *new_max = nullptr) {
   auto new_max__ = new_max ? _fbb.CreateVector<uint64_t>(*new_max) : 0;
-  auto drop_max__ = drop_max ? _fbb.CreateVector<uint64_t>(*drop_max) : 0;
   return rpc::CreateSignalUpdateRaw(
       _fbb,
-      new_max__,
-      drop_max__);
+      new_max__);
 }
 
 flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw(flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateRawT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2821,7 +2806,6 @@ inline void SignalUpdateRaw::UnPackTo(SignalUpdateRawT *_o, const flatbuffers::r
   (void)_o;
   (void)_resolver;
   { auto _e = new_max(); if (_e) { _o->new_max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_max[_i] = _e->Get(_i); } } }
-  { auto _e = drop_max(); if (_e) { _o->drop_max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->drop_max[_i] = _e->Get(_i); } } }
 }
 
 inline flatbuffers::Offset<SignalUpdateRaw> SignalUpdateRaw::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateRawT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2833,11 +2817,9 @@ inline flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw(flatbuffers::F
   (void)_o;
   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SignalUpdateRawT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
   auto _new_max = _o->new_max.size() ? _fbb.CreateVector(_o->new_max) : 0;
-  auto _drop_max = _o->drop_max.size() ? _fbb.CreateVector(_o->drop_max) : 0;
   return rpc::CreateSignalUpdateRaw(
       _fbb,
-      _new_max,
-      _drop_max);
+      _new_max);
 }
 
 inline CorpusTriagedRawT *CorpusTriagedRaw::UnPack(const flatbuffers::resolver_function_t *_resolver) const {