relax drift? to match the paper and unburden the client

Author: langmartin

lib/hlclock/server.ex

@@ -34,13 +34,10 @@ defmodule HLClock.Server do
   end
 
   def handle_call(:send_timestamp, _from, data) do
-    case Timestamp.send(data.timestamp, physical_time(), data.max_drift) do
-      {:ok, timestamp} ->
-        {:reply, {:ok, timestamp}, %{data | timestamp: timestamp}}
+    {:ok, timestamp} =
+      Timestamp.send(data.timestamp, physical_time(), data.max_drift)
 
-      {:error, error} ->
-        {:reply, {:error, error}, data}
-    end
+    {:reply, {:ok, timestamp}, %{data | timestamp: timestamp}}
   end
 
   def handle_call(
@@ -60,13 +57,8 @@ defmodule HLClock.Server do
   def handle_info(:periodic_send, data) do
     Process.send_after(self(), :periodic_send, interval(data))
 
-    case Timestamp.send(data.timestamp, physical_time(), data.max_drift) do
-      {:ok, ts} ->
-        {:noreply, %{data | timestamp: ts}}
-
-      {:error, _} ->
-        {:noreply, data}
-    end
+    {:ok, ts} = Timestamp.send(data.timestamp, physical_time(), data.max_drift)
+    {:noreply, %{data | timestamp: ts}}
   end
 
   defp physical_time, do: System.os_time(:millisecond)

lib/hlclock/timestamp.ex

@@ -10,6 +10,8 @@ defmodule HLClock.Timestamp do
   languages/representations.
   """
 
+  import Kernel, except: [send: 2]
+
   defstruct [:time, :counter, :node_id]
 
   alias __MODULE__, as: T
@@ -41,13 +43,24 @@ defmodule HLClock.Timestamp do
   Generate a single HLC Timestamp for sending to other nodes or
   local causality tracking
   """
-  def send(%{time: old_time, counter: counter, node_id: node_id}, pt, max_drift) do
+  def send(%{time: old_time, counter: counter, node_id: node_id}, pt) do
     new_time = max(old_time, pt)
     new_counter = advance_counter(old_time, counter, new_time)
 
-    with :ok <- handle_drift(old_time, new_time, max_drift) do
-      {:ok, new(new_time, new_counter, node_id)}
-    end
+    # We were checking drift exception here, but functionally that
+    # only catches errors caused by a system adminstrator setting the
+    # system clock to jump or, more commonly, causing an error
+    # whenever the computer running the vm sleeps.
+    {:ok, new(new_time, new_counter, node_id)}
+  end
+
+  # Compatibility for older users of Timestamp that may be providing the max_drift.
+  def send(
+        %{time: old_time, counter: counter, node_id: node_id},
+        pt,
+        _max_drift
+      ) do
+    send(%{time: old_time, counter: counter, node_id: node_id}, pt)
   end
 
   @doc """
@@ -185,8 +198,15 @@ defmodule HLClock.Timestamp do
     end
   end
 
+  # This was enforcing drift against abs(l - pt) which causes
+  # timestamps in the past to raise a drift exception. The algorithm
+  # only requires protecting ourselves against drift into the future
+  # compared to our physical clock. Relaxing this constraint makes it
+  # easier to always recv timestamps, simplifying client
+  # implementations. Clients need to recv every timestamp that could
+  # be in the future to preserve the causal order.
   defp drift?(l, pt, max_drift) do
-    abs(l - pt) > max_drift
+    l - pt > max_drift
   end
 
   defp advance_counter(old_time, counter, new_time) do

test/hlclock/timestamp_test.exs

@@ -104,12 +104,6 @@ defmodule HLClock.TimestampTest do
       assert t0.time == t1.time
       assert t1.counter == 1
     end
-
-    test "send can fail due to excessive drift" do
-      t0 = Timestamp.new(0, 0, 0)
-      {:error, err} = Timestamp.send(t0, 5 + 1, @max_drift)
-      assert err == :clock_drift_violation
-    end
   end
 
   describe "recv_timestamp/2" do