How to run Nemotron-3.5-Bolt-74B-A9B IQ2 QAT on 2× RTX 5060 Ti 16 GB

defmodule KVStore do
  @default_ttl 3_600_000          # 1 hour
  @default_interval 60_000        # 60 s

  @type t :: %{
    entries: map(),
    default_ttl: pos_integer(),
    interval: pos_integer(),
    hits: non_neg_integer(),
    misses: non_neg_integer(),
    timer: reference() | nil
  }

  @spec start_link(options :: keyword()) :: GenServer.gen_server_result()
  def start_link(options \ []) when is_list(options) do
    GenServer.start_link(__MODULE__, options)
  end

  @spec start_link(name :: atom(), options :: keyword()) :: GenServer.gen_server_result()
  def start_link(name, options \ []) when is_atom(name) and is_list(options) do
    GenServer.start_link(__MODULE__, Keyword.put(options, :name, name))
  end

  @spec put(store, key :: binary(), value :: binary()) :: :ok
  def put(store, key, value) do
    validate_key(key)
    validate_value(value)
    GenServer.call(store, {:put, key, value})
  end

  @spec put(store, key :: binary(), value :: binary(), ttl :: pos_integer()) :: :ok
  def put(store, key, value, ttl) do
    validate_key(key)
    validate_value(value)
    validate_ttl(ttl)
    GenServer.call(store, {:put, key, value, ttl})
  end

  @spec get(store, key :: binary()) :: binary() | nil
  def get(store, key) do
    validate_key(key)
    GenServer.call(store, {:get, key})
  end

  @spec delete(store, key :: binary()) :: boolean()
  def delete(store, key) do
    validate_key(key)
    GenServer.call(store, {:delete, key})
  end

  @spec stats(store) :: %{size: non_neg_integer(), hits: non_neg_integer(), misses: non_neg_integer(), memory: non_neg_integer()}
  def stats(store) do
    GenServer.call(store, {:stats})
  end

  defp validate_key(key) when is_binary(key), do: key
  defp validate_key(_key), do: raise ArgumentError, "key must be a binary"

  defp validate_value(value) when is_binary(value), do: value
  defp validate_value(_value), do: raise ArgumentError, "value must be a binary"

  defp validate_ttl(ttl) when is_integer(ttl) and ttl > 0, do: ttl
  defp validate_ttl(_ttl), do: raise ArgumentError, "ttl must be a positive integer"

  defp validate_interval(interval) when is_integer(interval) and interval > 0, do: interval
  defp validate_interval(_interval), do: raise ArgumentError, "interval must be a positive integer"

  @impl true
  def init(options) do
    default_ttl = validate_ttl(Keyword.get(options, :default_ttl, @default_ttl))
    interval = validate_interval(Keyword.get(options, :interval, @default_interval))
    state = %{entries: %{}, default_ttl: default_ttl, interval: interval, hits: 0, misses: 0, timer: nil}
    {:ok, schedule_evict(state, interval)}
  end

  @impl true
  def handle_info(:evict, state) do
    {:noreply, state |> evict_expired() |> schedule_evict(state.interval)}
  end

  defp evict_expired(state) do
    now = System.monotonic_time(:millisecond)
    expired = for {key, {_value, expires_at}} <- state.entries, expires_at <= now, do: key
    %{state | entries: Map.drop(state.entries, expired)}
  end

  defp schedule_evict(state, interval) do
    %{state | timer: Process.send_after(self(), :evict, interval)}
  end

  @impl true
  def handle_call({:put, key, value, ttl}, _from, state) do
    expires_at = System.monotonic_time(:millisecond) + ttl
    {:reply, :ok, %{state | entries: Map.put(state.entries, key, {value, expires_at})}}
  end

  @impl true
  def handle_call({:stats}, _from, state) do
    memory = Enum.reduce(state.entries, 0, fn {k, {v, _}}, acc -> acc + byte_size(k) + byte_size(v) + 64 end)
    {:reply, %{size: map_size(state.entries), hits: state.hits, misses: state.misses, memory: memory}, state}
  end

  @impl true
  def terminate(_reason, state) do
    case state.timer do
      nil -> :ok
      ref -> Process.cancel_timer(ref)
    end
  end
end