Ludicrous Mode

dgraph/cmd/alpha/run.go

@@ -189,7 +189,7 @@ they form a Raft group and provide synchronous replication.
 	grpc.EnableTracing = false
 
 	flag.Bool("graphql_introspection", true, "Set to false for no GraphQL schema introspection")
-
+	flag.Bool("ludicrous-mode", false, "Run alpha in ludicrous mode")
 }
 
 func setupCustomTokenizers() {
@@ -578,6 +578,7 @@ func run() {
 		SnapshotAfter:       Alpha.Conf.GetInt("snapshot_after"),
 		AbortOlderThan:      abortDur,
 		StartTime:           startTime,
+		LudicrousMode:       Alpha.Conf.GetBool("ludicrous-mode"),
 	}
 
 	setupCustomTokenizers()

dgraph/cmd/live/batch.go

@@ -237,6 +237,7 @@ func fingerprintEdge(t *pb.DirectedEdge, pred *predicate) uint64 {
 }
 
 func (l *loader) conflictKeysForNQuad(nq *api.NQuad) ([]uint64, error) {
+	return nil, nil
 	pred, found := l.schema.preds[nq.Predicate]
 
 	// We dont' need to generate conflict keys for predicate with noconflict directive.

dgraph/cmd/zero/raft.go

@@ -675,14 +675,16 @@ func (n *node) Run() {
 				}
 			}
 			n.SaveToStorage(&rd.HardState, rd.Entries, &rd.Snapshot)
-			timer.Record("disk")
-			if rd.MustSync {
-				if err := n.Store.Sync(); err != nil {
-					glog.Errorf("Error while calling Store.Sync: %v", err)
+			if !x.WorkerConfig.LudicrousMode {
+				timer.Record("disk")
+				if rd.MustSync {
+					if err := n.Store.Sync(); err != nil {
+						glog.Errorf("Error while calling Store.Sync: %v", err)
+					}
+					timer.Record("sync")
 				}
-				timer.Record("sync")
+				span.Annotatef(nil, "Saved to storage")
 			}
-			span.Annotatef(nil, "Saved to storage")
 
 			if !raft.IsEmptySnap(rd.Snapshot) {
 				var state pb.MembershipState

edgraph/server.go

@@ -323,6 +323,13 @@ func (s *Server) doMutate(ctx context.Context, qc *queryContext, resp *api.Respo
 	qc.span.Annotatef(nil, "Applying mutations: %+v", m)
 	resp.Txn, err = query.ApplyMutations(ctx, m)
 	qc.span.Annotatef(nil, "Txn Context: %+v. Err=%v", resp.Txn, err)
+
+	if x.WorkerConfig.LudicrousMode {
+		return err
+	}
+
+	// what are the cases in which a transaction could be aborted. Doesn it make sense
+	// to abort txn in ludicrous mode ??
 	if !qc.req.CommitNow {
 		if err == zero.ErrConflict {
 			err = status.Error(codes.FailedPrecondition, err.Error())
@@ -794,15 +801,28 @@ func (s *Server) doQuery(ctx context.Context, req *api.Request, doAuth AuthMode)
 	// assigned in the processQuery function called below.
 	defer annotateStartTs(qc.span, qc.req.StartTs)
 	// For mutations, we update the startTs if necessary.
+	var startTs uint64
 	if isMutation && req.StartTs == 0 {
 		start := time.Now()
-		req.StartTs = worker.State.GetTimestamp(false)
+		if !x.WorkerConfig.LudicrousMode {
+			startTs = worker.State.GetTimestamp(false)
+			req.StartTs = startTs
+		} else {
+			req.StartTs = posting.Oracle().MaxAssigned()
+			if len(qc.req.GetMutations()) > 0 {
+				startTs = worker.State.GetTimestamp(false)
+			}
+		}
 		qc.latency.AssignTimestamp = time.Since(start)
 	}
 
 	if resp, rerr = processQuery(ctx, qc); rerr != nil {
 		return
 	}
+
+	if x.WorkerConfig.LudicrousMode {
+		req.StartTs = startTs
+	}
 	if rerr = s.doMutate(ctx, qc, resp); rerr != nil {
 		return
 	}
@@ -856,7 +876,11 @@ func processQuery(ctx context.Context, qc *queryContext) (*api.Response, error)
 
 	if qc.req.StartTs == 0 {
 		assignTimestampStart := time.Now()
-		qc.req.StartTs = worker.State.GetTimestamp(qc.req.ReadOnly)
+		if !x.WorkerConfig.LudicrousMode {
+			qc.req.StartTs = worker.State.GetTimestamp(qc.req.ReadOnly)
+		} else {
+			qc.req.StartTs = posting.Oracle().MaxAssigned()
+		}
 		qc.latency.AssignTimestamp = time.Since(assignTimestampStart)
 	}
 

posting/list.go

@@ -398,6 +398,10 @@ func (l *List) addMutationInternal(ctx context.Context, txn *Txn, t *pb.Directed
 	}
 	l.updateMutationLayer(mpost)
 
+	if x.WorkerConfig.LudicrousMode {
+		return nil
+	}
+
 	// We ensure that commit marks are applied to posting lists in the right
 	// order. We can do so by proposing them in the same order as received by the Oracle delta
 	// stream from Zero, instead of in goroutines.

worker/draft.go

@@ -347,6 +347,14 @@ func (n *node) applyCommitted(proposal *pb.Proposal) error {
 			span.Annotatef(nil, "While applying mutations: %v", err)
 			return err
 		}
+		if x.WorkerConfig.LudicrousMode {
+			txnTimeStamp := proposal.Mutations.StartTs
+			return n.commitOrAbort(proposal.Key, &pb.OracleDelta{
+				Txns: []*pb.TxnStatus{
+					{StartTs: txnTimeStamp, CommitTs: txnTimeStamp},
+				},
+			})
+		}
 		span.Annotate(nil, "Done")
 		return nil
 	}
@@ -554,12 +562,20 @@ func (n *node) commitOrAbort(pkey string, delta *pb.OracleDelta) error {
 	for _, status := range delta.Txns {
 		toDisk(status.StartTs, status.CommitTs)
 	}
-	if err := writer.Flush(); err != nil {
-		return errors.Wrapf(err, "while flushing to disk")
+	if x.WorkerConfig.LudicrousMode {
+		go func() {
+			writer.Flush()
+		}()
+	} else {
+		if err := writer.Flush(); err != nil {
+			return errors.Wrapf(err, "while flushing to disk")
+		}
 	}
 
 	g := groups()
-	atomic.StoreUint64(&g.deltaChecksum, delta.GroupChecksums[g.groupId()])
+	if delta.GroupChecksums != nil {
+		atomic.StoreUint64(&g.deltaChecksum, delta.GroupChecksums[g.groupId()])
+	}
 
 	// Now advance Oracle(), so we can service waiting reads.
 	posting.Oracle().ProcessDelta(delta)
@@ -906,18 +922,20 @@ func (n *node) Run() {
 
 			// Store the hardstate and entries. Note that these are not CommittedEntries.
 			n.SaveToStorage(&rd.HardState, rd.Entries, &rd.Snapshot)
-			timer.Record("disk")
-			if rd.MustSync {
-				if err := n.Store.Sync(); err != nil {
-					glog.Errorf("Error while calling Store.Sync: %+v", err)
+			if !x.WorkerConfig.LudicrousMode {
+				timer.Record("disk")
+				if rd.MustSync {
+					if err := n.Store.Sync(); err != nil {
+						glog.Errorf("Error while calling Store.Sync: %+v", err)
+					}
+					timer.Record("sync")
+				}
+				if span != nil {
+					span.Annotatef(nil, "Saved %d entries. Snapshot, HardState empty? (%v, %v)",
+						len(rd.Entries),
+						raft.IsEmptySnap(rd.Snapshot),
+						raft.IsEmptyHardState(rd.HardState))
 				}
-				timer.Record("sync")
-			}
-			if span != nil {
-				span.Annotatef(nil, "Saved %d entries. Snapshot, HardState empty? (%v, %v)",
-					len(rd.Entries),
-					raft.IsEmptySnap(rd.Snapshot),
-					raft.IsEmptyHardState(rd.HardState))
 			}
 
 			// Now schedule or apply committed entries.
@@ -953,6 +971,11 @@ func (n *node) Run() {
 						if span := otrace.FromContext(pctx.Ctx); span != nil {
 							span.Annotate(nil, "Proposal found in CommittedEntries")
 						}
+						if x.WorkerConfig.LudicrousMode {
+							// Assuming that there will be no error
+							// while proposing.
+							n.Proposals.Done(proposal.Key, nil)
+						}
 					}
 					proposal.Index = entry.Index
 					proposals = append(proposals, proposal)

x/config.go

@@ -76,6 +76,8 @@ type WorkerOptions struct {
 	ProposedGroupId uint32
 	// StartTime is the start time of the alpha
 	StartTime time.Time
+	// LudicrousMode is super fast mode with fewer guarantees.
+	LudicrousMode bool
 }
 
 // WorkerConfig stores the global instance of the worker package's options.