Optimise snapshotting by moving the call to ra_machine:live_indexes

to the snapshot process _if_ the Ref returned from ra_snapshot:prepare/2
is the same term as the machine state.

Author: kjnilsson

src/ra_log_wal.erl

@@ -757,8 +757,8 @@ dump_records(<<_:1/unsigned, 0:1/unsigned, _:22/unsigned,
                _EntryData:0/binary,
                _Rest/binary>>, Entries) ->
     Entries;
-dump_records(<<_:1/unsigned, 0:1/unsigned, Id2:22/unsigned,
-               IdDataLen:16/unsigned, Id:IdDataLen/binary,
+dump_records(<<_:1/unsigned, 0:1/unsigned, _Id2:22/unsigned,
+               IdDataLen:16/unsigned, _Id:IdDataLen/binary,
                Crc:32/integer,
                EntryDataLen:32/unsigned,
                Idx:64/unsigned, Term:64/unsigned,
@@ -767,19 +767,19 @@ dump_records(<<_:1/unsigned, 0:1/unsigned, Id2:22/unsigned,
     % TODO: recover writers info, i.e. last index seen
     case erlang:adler32(<<Idx:64/unsigned, Term:64/unsigned, EntryData/binary>>) of
         Crc ->
-            dump_records(Rest, [{{Id, Id2}, {Idx, Term, binary_to_term(EntryData)}} | Entries]);
+            dump_records(Rest, [{Idx, Term, binary_to_term(EntryData)} | Entries]);
         _ ->
             exit({crc_failed_for, Idx, EntryData})
     end;
-dump_records(<<_:1/unsigned, 1:1/unsigned, Id:22/unsigned,
+dump_records(<<_:1/unsigned, 1:1/unsigned, _Id:22/unsigned,
                Crc:32/integer,
                EntryDataLen:32/unsigned,
                Idx:64/unsigned, Term:64/unsigned,
                EntryData:EntryDataLen/binary,
                Rest/binary>>, Entries) ->
     case erlang:adler32(<<Idx:64/unsigned, Term:64/unsigned, EntryData/binary>>) of
         Crc ->
-            dump_records(Rest, [{Id, {Idx, Term, binary_to_term(EntryData)}} | Entries]);
+            dump_records(Rest, [{Idx, Term, binary_to_term(EntryData)} | Entries]);
         _ ->
             exit({crc_failed_for, Idx, EntryData})
     end;

src/ra_snapshot.erl

@@ -390,33 +390,48 @@ begin_snapshot(#{index := Idx, term := Term} = Meta, MacMod, MacState, SnapKind,
     Sync = SnapKind =:= snapshot,
     %% create directory for this snapshot
     SnapDir = make_snapshot_dir(Dir, Idx, Term),
-    %% TODO: really we'd like to run this in the ra worker as good potentially
-    %% be quite large and a touch expensive to compute but also we don't want
-    %% to close over both the MacState and the MacRef
-    LiveIndexes = ra_seq:from_list(ra_machine:live_indexes(MacMod, MacState)),
-    %% call prepare then write_snapshotS
     %% This needs to be called in the current process to "lock" potentially
     %% mutable machine state
     Ref = Mod:prepare(Meta, MacState),
+    PostPrepareEqualsMacState = Ref == MacState,
+    LiveIndexes0 = case PostPrepareEqualsMacState of
+                       false ->
+                           ra_seq:from_list(
+                             ra_machine:live_indexes(MacMod, MacState));
+                       true ->
+                           []
+                   end,
     %% write the snapshot in a separate process
     Self = self(),
     IdxTerm = {Idx, Term},
     BgWorkFun = fun () ->
                         ok = ra_lib:make_dir(SnapDir),
+                        %% if the Ref returned by ra_snapshot:prepare/2 is
+                        %% the same as the mac state then indexes can be
+                        %% calculated here
+                        LiveIndexes =
+                            case PostPrepareEqualsMacState of
+                                true ->
+                                    ra_seq:from_list(
+                                      ra_machine:live_indexes(MacMod, Ref));
+                                false ->
+                                    LiveIndexes0
+                            end,
                         case Mod:write(SnapDir, Meta, Ref, Sync) of
                             ok -> ok;
                             {ok, BytesWritten} ->
                                 counters_add(Counter, CounterIdx,
                                              BytesWritten),
                                 ok
                         end,
-                        %% write the live indexes, if any
+
                         case LiveIndexes of
                             [] -> ok;
                             _ ->
                                 ok = write_indexes(SnapDir, LiveIndexes),
                                 ok
                         end,
+
                         Self ! {ra_log_event,
                                 {snapshot_written, IdxTerm,
                                  LiveIndexes, SnapKind}},