Current section
Files
Jump to
Current section
Files
src/ets_cache.erl
%%%-------------------------------------------------------------------
%%% @author Evgeny Khramtsov <ekhramtsov@process-one.net>
%%% Created : 12 Apr 2017 by Evgeny Khramtsov <ekhramtsov@process-one.net>
%%%
%%%
%%% Copyright (C) 2002-2021 ProcessOne, SARL. All Rights Reserved.
%%%
%%% Licensed under the Apache License, Version 2.0 (the "License");
%%% you may not use this file except in compliance with the License.
%%% You may obtain a copy of the License at
%%%
%%% http://www.apache.org/licenses/LICENSE-2.0
%%%
%%% Unless required by applicable law or agreed to in writing, software
%%% distributed under the License is distributed on an "AS IS" BASIS,
%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%%% See the License for the specific language governing permissions and
%%% limitations under the License.
%%%
%%%-------------------------------------------------------------------
-module(ets_cache).
-behaviour(gen_server).
%% API
-export([start_link/2]).
-export([new/1, new/2, delete/1]).
-export([delete/2, delete/3, match_delete/2, match_delete/3]).
-export([lookup/2, lookup/3]).
-export([insert/3, insert/4, insert_new/3, insert_new/4]).
-export([update/4, update/5]).
-export([incr/3, incr/4]).
-export([setopts/2, all/0, info/1, info/2]).
-export([clear/1, clear/2, clean/1, clean/2]).
-export([filter/2, fold/3]).
-export([untag/1]).
%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
terminate/2, code_change/3]).
%% Counters: for tests *only*, don't use them outside this module
-export([new_counter/0, get_counter/1, incr_counter/1, delete_counter/1,
new_counter_nif/0, get_counter_nif/1, incr_counter_nif/1,
delete_counter_nif/1]).
-compile(no_native).
-on_load(load_nif/0).
-include_lib("stdlib/include/ms_transform.hrl").
-record(state, {tab :: atom(),
clean_timer :: reference(),
counter :: counter() | undefined,
cache_missed = true :: boolean(),
life_time = infinity :: milli_seconds() | infinity,
max_size = infinity :: pos_integer() | infinity}).
-define(DEFAULT_MAX_CACHE_TABLES, 1024).
-define(IS_EXPIRED(Time, LifeTime, CurrTime),
(is_integer(LifeTime) andalso (Time + LifeTime =< CurrTime))).
-type tag() :: cache | nocache.
-type counter() :: non_neg_integer().
-type milli_seconds() :: pos_integer().
-type option() :: {max_size, pos_integer() | infinity} |
{life_time, milli_seconds() | infinity} |
{cache_missed, boolean()} |
{type, set | ordered_set | bag | duplicate_bag}.
-type read_fun() :: fun(() -> {ok, any()} | error).
-type update_fun() :: fun(() -> ok | {ok, any()} | error).
-type filter_fun() :: fun((any(), {ok, any()} | error) -> boolean()).
-type fold_fun() :: fun((any(), {ok, any()} | error, any()) -> any()).
-type state() :: #state{}.
-export_type([tag/0]).
-dialyzer({no_match, [handle_info/2, check_size/2, insert/5, do_insert/5,
do_filter/6, do_fold/6, delete_if_expired/4,
delete_if_expired/2]}).
-dialyzer({no_return, terminate/2}).
-dialyzer({no_unused, calculate_time/2}).
-dialyzer({[no_match, no_return], [delete_counter/1, get_counter/1,
incr_counter/1]}).
%%%===================================================================
%%% API
%%%===================================================================
start_link(Name, Opts) ->
gen_server:start_link({local, Name}, ?MODULE,
[Name, Opts], []).
-spec new(atom()) -> ok.
new(Name) ->
new(Name, []).
-spec new(atom(), [option()]) -> ok.
new(Name, Opts) ->
Opts1 = check_opts(Opts),
case whereis(Name) of
undefined ->
Spec = {Name, {?MODULE, start_link, [Name, Opts1]},
transient, 5000, worker, [?MODULE]},
case supervisor:start_child(cache_tab_sup, Spec) of
{ok, _Pid} -> ok;
{error, {already_started, _}} -> setopts(Name, Opts1);
{error, Err} -> erlang:error(Err)
end;
_ ->
setopts(Name, Opts1)
end.
-spec setopts(atom(), [option()]) -> ok.
setopts(Name, Opts) ->
Opts1 = check_opts(Opts),
gen_server:cast(Name, {setopts, Opts1}).
-spec delete(atom()) -> ok.
delete(Name) ->
supervisor:terminate_child(cache_tab_sup, Name),
supervisor:delete_child(cache_tab_sup, Name),
ok.
-spec delete(atom(), any()) -> ok.
delete(Name, Key) ->
delete(Name, Key, [node()]).
-spec delete(atom(), any(), [atom()]) -> ok.
delete(Name, Key, Nodes) ->
lists:foreach(
fun(Node) when Node /= node() ->
send({Name, Node}, {delete, Key});
(_MyNode) ->
ets_delete(Name, Key)
end, Nodes).
-spec match_delete(atom(), any()) -> ok.
match_delete(Name, Match) ->
match_delete(Name, Match, [node()]).
-spec match_delete(atom(), any(), [atom()]) -> ok.
match_delete(Name, Match, Nodes) ->
lists:foreach(
fun(Node) when Node /= node() ->
send({Name, Node}, {match_delete, Match});
(_MyNode) ->
ets_match_delete(Name, Match)
end, Nodes).
-spec insert(atom(), any(), any()) -> boolean().
insert(Name, Key, Val) ->
insert(Name, Key, Val, [node()]).
-spec insert(atom(), any(), any(), [node()]) -> boolean().
insert(Name, Key, Val, Nodes) ->
insert(replace, Name, Key, Val, Nodes).
-spec insert_new(atom(), any(), any()) -> boolean().
insert_new(Name, Key, Val) ->
insert(Name, Key, Val, [node()]).
-spec insert_new(atom(), any(), any(), [node()]) -> boolean().
insert_new(Name, Key, Val, Nodes) ->
insert(new, Name, Key, Val, Nodes).
-spec lookup(atom(), any()) -> {ok, any()} | any().
lookup(Name, Key) ->
lookup(Name, Key, error).
-spec lookup(atom(), any(), read_fun() | term()) -> {ok, any()} | any().
lookup(Name, Key, Return) ->
try ets:lookup(Name, Key) of
[{_, Val, _} = Obj] ->
delete_if_expired(Name, Obj),
Val;
[] when is_function(Return) ->
Ver = get_counter(Name),
case case Return() of
{ok, _} = Ret -> {cache, Ret};
error -> {cache, error};
{error, notfound} -> {cache, error};
{cache, _} = Ret -> Ret;
{cache_with_timeout, _, _} = Ret -> Ret;
{nocache, _} = Ret -> Ret;
Other -> {nocache, Other}
end of
{nocache, Val} ->
Val;
{cache_with_timeout, Val, Timeout} ->
case get_counter(Name) of
Ver ->
Time = calculate_time(Name, Timeout),
do_insert(new, Name, {Key, Val, Time});
_ ->
ok
end,
Val;
{cache, Val} ->
case get_counter(Name) of
Ver ->
do_insert(new, Name, {Key, Val, current_time()});
_ ->
ok
end,
Val
end;
[] ->
Return
catch _:badarg when is_function(Return) ->
untag(Return());
_:badarg ->
Return
end.
-spec update(atom(), any(), {ok, any()} | error, update_fun()) -> ok | any().
update(Name, Key, Val, UpdateFun) ->
update(Name, Key, Val, UpdateFun, [node()]).
-spec update(atom(), any(), {ok, any()} | error, update_fun(), [node()]) -> ok | any().
update(Name, Key, Val, UpdateFun, Nodes) ->
NeedUpdate = try ets:lookup(Name, Key) of
[{_, Val, _} = Obj] ->
delete_if_expired(Name, Obj);
_ ->
true
catch _:badarg ->
true
end,
if NeedUpdate ->
case case UpdateFun() of
ok -> {cache, Val};
{ok, _} = Ret -> {cache, Ret};
error -> {cache, error};
{error, notfound} -> {cache, error};
{cache, _} = Ret -> Ret;
{nocache, _} = Ret -> Ret;
Other -> {nocache, Other}
end of
{nocache, NewVal} ->
NewVal;
{cache, NewVal} ->
lists:foreach(
fun(Node) when Node /= node() ->
send({Name, Node}, {delete, Key});
(_) ->
do_insert(replace, Name, {Key, NewVal, current_time()})
end, Nodes),
NewVal
end;
true ->
Val
end.
-spec incr(atom(), any(), non_neg_integer()) -> ok.
incr(Name, Key, Incr) ->
incr(Name, Key, Incr, [node()]).
-spec incr(atom(), any(), non_neg_integer(), [node()]) -> ok.
incr(Name, Key, Incr, Nodes) ->
Obj = {Key, Incr, current_time()},
lists:foreach(
fun(Node) when Node /= node() ->
send({Name, Node}, {incr, Obj});
(_) ->
do_insert(incr, Name, Obj)
end, Nodes).
-spec clear(atom()) -> ok.
clear(Name) ->
clear(Name, [node()]).
-spec clear(atom(), [atom()]) -> ok.
clear(Name, Nodes) ->
lists:foreach(
fun(Node) when Node /= node() ->
send({Name, Node}, clear);
(_MyNode) ->
ets_delete_all_objects(Name)
end, Nodes).
-spec clean(atom()) -> ok.
clean(Name) ->
clean(Name, [node()]).
-spec clean(atom(), [node()]) -> ok.
clean(Name, Nodes) ->
lists:foreach(
fun(Node) ->
send({Name, Node}, clean)
end, Nodes).
-spec filter(atom(), filter_fun()) -> non_neg_integer().
filter(Name, FilterFun) ->
case whereis(Name) of
undefined -> 0;
_ ->
{ok, LifeTime} = ets_cache_options:life_time(Name),
CurrTime = current_time(),
ets_safe_fixtable(Name, true),
Num = do_filter(Name, FilterFun, LifeTime, CurrTime,
0, ets_first(Name)),
ets_safe_fixtable(Name, false),
Num
end.
-spec fold(fold_fun(), any(), atom()) -> any().
fold(FoldFun, Acc, Name) ->
case whereis(Name) of
undefined -> Acc;
_ ->
{ok, LifeTime} = ets_cache_options:life_time(Name),
CurrTime = current_time(),
ets_safe_fixtable(Name, true),
NewAcc = do_fold(Name, FoldFun, LifeTime, CurrTime,
Acc, ets_first(Name)),
ets_safe_fixtable(Name, false),
NewAcc
end.
-spec all() -> [atom()].
all() ->
[Child || {Child, _, _, [?MODULE]} <- supervisor:which_children(cache_tab_sup)].
-spec info(atom()) -> [proplists:property()].
info(Name) ->
case ets:info(Name) of
undefined ->
[];
ETSInfo ->
{ok, MaxSize} = ets_cache_options:max_size(Name),
{ok, CacheMissed} = ets_cache_options:cache_missed(Name),
{ok, LifeTime} = ets_cache_options:life_time(Name),
[{max_size, MaxSize},
{cache_missed, CacheMissed},
{life_time, LifeTime}
|lists:filtermap(
fun({memory, V}) ->
{true, {memory, V * erlang:system_info(wordsize)}};
({owner, _}) -> true;
({name, _}) -> true;
({size, _}) -> true;
({type, _}) -> true;
(_) -> false
end, ETSInfo)]
end.
-spec info(atom(), atom()) -> any().
info(Name, Option) ->
Options = info(Name),
case lists:keyfind(Option, 1, Options) of
{_, Value} -> Value;
_ -> erlang:error(badarg)
end.
-spec untag(term()) -> term().
untag({cache, Val}) -> Val;
untag({nocache, Val}) -> Val;
untag(Val) -> Val.
load_nif() ->
case os:getenv("COVERALLS") of
"true" -> ok;
_ -> load_nif2()
end.
load_nif2() ->
Path = p1_nif_utils:get_so_path(?MODULE, [?MODULE], atom_to_list(?MODULE)),
MaxTables = get_max_tables(),
case erlang:load_nif(Path, MaxTables) of
ok -> ok;
{error, {Reason, Text}} ->
error_logger:error_msg("Failed to load NIF ~s: ~s (~p)",
[Path, Text, Reason]),
erlang:nif_error(Reason)
end.
%%%===================================================================
%%% gen_server callbacks
%%%===================================================================
init([Name, Opts]) ->
process_flag(trap_exit, true),
Type = proplists:get_value(type, Opts, set),
ets:new(Name, [named_table, public, {read_concurrency, true}, Type]),
Counter = new_counter(),
TRef = start_clean_timer(),
State = #state{tab = Name, clean_timer = TRef},
{ok, do_setopts(State, [{counter, Counter}|Opts])}.
handle_call(_Request, _From, State) ->
Reply = ok,
{reply, Reply, State}.
handle_cast({setopts, Opts}, State) ->
{noreply, do_setopts(State, Opts)};
handle_cast(_Msg, State) ->
{noreply, State}.
handle_info({insert, Op, {Key, _, CurrTime} = New}, #state{tab = Tab} = State) ->
case ets:lookup(Tab, Key) of
[Old] ->
case delete_if_expired(Tab, Old, CurrTime) of
true ->
do_insert(Op, Tab, New);
false ->
ok
end;
[] ->
do_insert(Op, Tab, New)
end,
{noreply, State};
handle_info({incr, Obj}, #state{tab = Tab} = State) ->
do_insert(incr, Tab, Obj),
{noreply, State};
handle_info({delete, Key}, #state{tab = Tab} = State) ->
ets_delete(Tab, Key),
{noreply, State};
handle_info({match_delete, Match}, #state{tab = Tab} = State) ->
ets_match_delete(Tab, Match),
{noreply, State};
handle_info(clear, #state{tab = Tab} = State) ->
ets_delete_all_objects(Tab),
{noreply, State};
handle_info(clean, #state{clean_timer = TRef} = State) ->
clean_expired(State),
NewTRef = start_clean_timer(TRef),
{noreply, State#state{clean_timer = NewTRef}};
handle_info(table_overflow, #state{tab = Tab, max_size = MaxSize} = State) ->
case ets:info(Tab, size) of
N when N >= MaxSize ->
error_logger:warning_msg(
"Shrinking cache '~s' (current size = ~B, max size = ~B, "
"life time = ~p, memory = ~B bytes); you should increase maximum "
"cache size if this message repeats too often",
[Tab, N, MaxSize, State#state.life_time,
ets:info(Tab, memory) * erlang:system_info(wordsize)]),
ets_delete_all_objects(Tab);
_ ->
ok
end,
{noreply, State};
handle_info(_Info, State) ->
{noreply, State}.
terminate(_Reason, #state{tab = Tab}) ->
delete_counter(Tab).
code_change(_OldVsn, State, _Extra) ->
{ok, State}.
%%%===================================================================
%%% Internal functions
%%%===================================================================
-spec check_size(atom(), pos_integer() | infinity) -> ok.
check_size(_Tab, infinity) ->
ok;
check_size(Tab, MaxSize) ->
try ets:info(Tab, size) of
N when N >= MaxSize ->
send({Tab, node()}, table_overflow);
_ ->
ok
catch _:badarg ->
ok
end.
-spec insert(new | replace, atom(), any(), any(), [node()]) -> boolean().
insert(Op, Name, Key, Val, Nodes) ->
CurrTime = current_time(),
Obj = {Key, {ok, Val}, CurrTime},
lists:foldl(
fun(Node, Result) when Node /= node() ->
send({Name, Node}, {insert, Op, Obj}),
Result;
(_, _) ->
try ets:lookup(Name, Key) of
[Old] ->
case delete_if_expired(Name, Old, CurrTime) of
true -> do_insert(Op, Name, Obj);
false -> false
end;
[] -> do_insert(Op, Name, Obj)
catch _:badarg ->
false
end
end, false, Nodes).
do_insert(Op, Name, Obj) ->
{ok, CacheMissed} = ets_cache_options:cache_missed(Name),
{ok, MaxSize} = ets_cache_options:max_size(Name),
do_insert(Op, Name, Obj, CacheMissed, MaxSize).
do_insert(_Op, _Name, {_Key, error, _Time}, _CacheMissed = false, _MaxSize) ->
false;
do_insert(Op, Name, Obj, _CacheMissed, MaxSize) ->
check_size(Name, MaxSize),
try
case Op of
new -> ets:insert_new(Name, Obj);
replace -> ets:insert(Name, Obj);
incr ->
incr_counter(Name),
{Key, Incr, Time} = Obj,
ets:update_counter(Name, Key, {2, Incr}),
ets:update_element(Name, Key, {3, Time})
end
catch _:badarg ->
false
end.
-spec do_filter(atom(), filter_fun(), pos_integer() | infinity,
integer(), non_neg_integer(), any()) -> non_neg_integer().
do_filter(_Name, _FilterFun, _LifeTime, _CurrTime, Num, '$end_of_table') ->
Num;
do_filter(Name, FilterFun, LifeTime, CurrTime, Num, Key) ->
NewNum = try ets:lookup(Name, Key) of
[{Key, Val, Time}] ->
if ?IS_EXPIRED(Time, LifeTime, CurrTime) ->
ets_delete_object(Name, {Key, Val, Time}),
Num;
true ->
case FilterFun(Key, Val) of
true ->
Num;
false ->
ets_delete_object(Name, {Key, Val, Time}),
Num + 1
end
end;
_ ->
Num
catch _:badarg ->
Num
end,
do_filter(Name, FilterFun, LifeTime, CurrTime, NewNum, ets_next(Name, Key)).
-spec do_fold(atom(), fold_fun(), pos_integer() | infinity,
integer(), any(), any()) -> any().
do_fold(_Name, _FoldFun, _LifeTime, _CurrTime, Acc, '$end_of_table') ->
Acc;
do_fold(Name, FoldFun, LifeTime, CurrTime, Acc, Key) ->
NewAcc = try ets:lookup(Name, Key) of
[{Key, Val, Time}] ->
if ?IS_EXPIRED(Time, LifeTime, CurrTime) ->
ets_delete_object(Name, {Key, Val, Time}),
Acc;
true ->
FoldFun(Key, Val, Acc)
end;
_ ->
Acc
catch _:badarg ->
Acc
end,
do_fold(Name, FoldFun, LifeTime, CurrTime, NewAcc, ets_next(Name, Key)).
-spec check_opts([option()]) -> [option()].
check_opts(Opts) ->
lists:map(
fun({Name, Val} = Opt) ->
case {Name, Val} of
{max_size, Val} when is_integer(Val), Val>0 -> Opt;
{max_size, infinity} -> Opt;
{life_time, Val} when is_integer(Val), Val>0 -> Opt;
{life_time, infinity} -> Opt;
{cache_missed, Bool} when is_boolean(Bool) -> Opt;
{type, Type} when Type == set;
Type == ordered_set;
Type == bag;
Type == duplicate_bag ->
Opt;
_ -> erlang:error({bad_option, Opt})
end;
(cache_missed) -> {cache_missed, true};
(Opt) -> erlang:error({bad_option, Opt})
end, Opts).
-spec do_setopts(state(), [{counter, counter()} | option()]) -> state().
do_setopts(State, Opts) ->
MaxSize = proplists:get_value(max_size, Opts, State#state.max_size),
LifeTime = proplists:get_value(life_time, Opts, State#state.life_time),
CacheMissed = proplists:get_value(cache_missed, Opts, State#state.cache_missed),
Counter = proplists:get_value(counter, Opts, State#state.counter),
NewState = State#state{max_size = MaxSize,
counter = Counter,
life_time = LifeTime,
cache_missed = CacheMissed},
if State == NewState ->
ok;
true ->
Tab = State#state.tab,
p1_options:insert(ets_cache_options, max_size, Tab, MaxSize),
p1_options:insert(ets_cache_options, life_time, Tab, LifeTime),
p1_options:insert(ets_cache_options, cache_missed, Tab, CacheMissed),
p1_options:insert(ets_cache_options, counter, Tab, Counter),
p1_options:compile(ets_cache_options)
end,
NewState.
-spec calculate_time(atom(), integer()) -> integer().
calculate_time(Name, Timeout) ->
Now = current_time(),
case ets_cache_options:life_time(Name) of
{ok, infinity} ->
Now;
{ok, LifeTime} ->
Now - LifeTime + Timeout
end.
-spec current_time() -> integer().
current_time() ->
erlang:system_time(millisecond).
-spec start_clean_timer() -> reference().
start_clean_timer() ->
start_clean_timer(make_ref()).
-spec start_clean_timer(reference()) -> reference().
start_clean_timer(TRef) ->
case erlang:cancel_timer(TRef) of
false ->
receive {timeout, TRef, _} -> ok
after 0 -> ok end;
_ -> ok
end,
Timeout = timer:minutes(1) + p1_rand:uniform(timer:minutes(4)),
erlang:send_after(Timeout, self(), clean).
-spec clean_expired(state()) -> non_neg_integer().
clean_expired(#state{tab = Tab, life_time = LifeTime}) ->
CurrTime = current_time(),
ets_select_delete(
Tab, ets:fun2ms(
fun({_, _, Time}) ->
?IS_EXPIRED(Time, LifeTime, CurrTime)
end)).
delete_if_expired(Name, Obj) ->
case ets_cache_options:life_time(Name) of
{ok, infinity} ->
false;
{ok, LifeTime} ->
delete_if_expired(Name, Obj, current_time(), LifeTime)
end.
delete_if_expired(Name, Obj, CurrTime) ->
{ok, LifeTime} = ets_cache_options:life_time(Name),
delete_if_expired(Name, Obj, CurrTime, LifeTime).
delete_if_expired(Name, {_, _, Time} = Obj, CurrTime, LifeTime) ->
if ?IS_EXPIRED(Time, LifeTime, CurrTime) ->
ets_delete_object(Name, Obj);
true ->
false
end.
send(Dst, Msg) ->
erlang:send(Dst, Msg, [noconnect, nosuspend]).
-spec ets_delete(atom(), any()) -> boolean().
ets_delete(Tab, Key) ->
try
incr_counter(Tab),
ets:delete(Tab, Key)
catch _:badarg ->
false;
_:{badmatch, undefined} ->
false
end.
-spec ets_match_delete(atom(), any()) -> boolean().
ets_match_delete(Tab, Match) ->
try
incr_counter(Tab),
ets:match_delete(Tab, {Match, '_', '_'})
catch _:badarg ->
false;
_:{badmatch, undefined} ->
false
end.
-spec ets_delete_object(atom(), any()) -> boolean().
ets_delete_object(Tab, Obj) ->
try
incr_counter(Tab),
ets:delete_object(Tab, Obj)
catch _:badarg ->
false;
_:{badmatch, undefined} ->
false
end.
-spec ets_delete_all_objects(atom()) -> boolean().
ets_delete_all_objects(Tab) ->
try
incr_counter(Tab),
ets:delete_all_objects(Tab)
catch _:badarg ->
false;
_:{badmatch, undefined} ->
false
end.
-spec ets_select_delete(atom(), ets:match_spec()) -> non_neg_integer().
ets_select_delete(Tab, Fun) ->
try
incr_counter(Tab),
ets:select_delete(Tab, Fun)
catch _:badarg ->
0
end.
-spec ets_first(atom()) -> any().
ets_first(Tab) ->
try ets:first(Tab)
catch _:badarg -> '$end_of_table'
end.
-spec ets_next(atom(), any()) -> any().
ets_next(Tab, Key) ->
try ets:next(Tab, Key)
catch _:badarg -> '$end_of_table'
end.
-spec ets_safe_fixtable(atom(), boolean()) -> boolean().
ets_safe_fixtable(Tab, Fix) ->
try ets:safe_fixtable(Tab, Fix)
catch _:badarg -> false
end.
get_max_tables() ->
case application:get_env(cache_tab, max_cache_tables) of
undefined -> ?DEFAULT_MAX_CACHE_TABLES;
{ok, I} when is_integer(I), I > 0 -> I;
{ok, Val} ->
error_logger:error_msg(
"Incorrect value of 'max_cache_tables' "
"application parameter: ~p", [Val]),
?DEFAULT_MAX_CACHE_TABLES
end.
%%%===================================================================
%%% Counters
%%%===================================================================
-spec new_counter() -> counter().
new_counter() ->
case new_counter_nif() of
{ok, Counter} ->
Counter;
{error, {system_limit, MaxTables}} ->
error_logger:error_msg(
"Maximum number (~B) of ETS cache tables has reached",
[MaxTables]),
erlang:error(system_limit)
end.
-spec get_counter(atom()) -> non_neg_integer().
get_counter(Name) ->
{ok, Counter} = ets_cache_options:counter(Name),
get_counter_nif(Counter).
-spec incr_counter(atom()) -> non_neg_integer().
incr_counter(Name) ->
{ok, Counter} = ets_cache_options:counter(Name),
incr_counter_nif(Counter).
-spec delete_counter(counter()) -> ok.
delete_counter(Name) ->
{ok, Counter} = ets_cache_options:counter(Name),
delete_counter_nif(Counter).
-spec new_counter_nif() -> {ok, counter()} | {error, {system_limit, pos_integer()}}.
new_counter_nif() ->
erlang:nif_error({nif_not_loaded, ?MODULE}).
-spec get_counter_nif(counter()) -> non_neg_integer().
get_counter_nif(_) ->
erlang:nif_error({nif_not_loaded, ?MODULE}).
-spec incr_counter_nif(counter()) -> non_neg_integer().
incr_counter_nif(_) ->
erlang:nif_error({nif_not_loaded, ?MODULE}).
-spec delete_counter_nif(counter()) -> ok.
delete_counter_nif(_) ->
erlang:nif_error({nif_not_loaded, ?MODULE}).