%% timer:tc/3 测量函数执行时间
{Time, Result} = timer:tc(lists, seq, [1, 1000000]),
io:format("Time: ~p μs, Result length: ~p~n", [Time, length(Result)]).

%% 测量代码块
benchmark() ->
    List = lists:seq(1, 100000),
    
    {T1, _} = timer:tc(lists, reverse, [List]),
    {T2, _} = timer:tc(lists, sort, [List]),
    
    io:format("reverse: ~p μs~n", [T1]),
    io:format("sort:    ~p μs~n", [T2]).

%% 计数器方式
-reduction_count

%% 启动 fprof
fprof:profile({my_module, my_function, [Args]}).

%% 或者分析代码块
fprof:apply(fun() ->
    lists:map(fun(X) -> X * 2 end, lists:seq(1, 10000))
end).

%% 查看结果
fprof:analyse().        %% 输出到文件
fprof:analyse(dest, []).  %% 输出到标准输出

%% 停止
fprof:stop().

%% 启动 eprof
eprof:start().

%% 分析特定进程
eprof:start_profiling([self()]).

%% 执行代码
lists:map(fun(X) -> X * 2 end, lists:seq(1, 100000)).

%% 停止 profiling 并查看结果
eprof:stop_profiling().
eprof:analyze().

%% 启动 cprof（开销最小）
cprof:start().

%% 执行代码
lists:seq(1, 1000).

%% 查看结果
cprof:pause().
{ok, {_, Count}} = cprof:data().

%% 查看特定模块
cprof:data(my_module).

%% 当前进程内存
process_info(self(), memory).

%% 所有进程内存汇总
erlang:memory().

%% [{total, 12345678},
%%  {processes, 8000000},
%%  {processes_used, 7500000},
%%  {system, 4345678},
%%  {atom, 500000},
%%  {atom_used, 450000},
%%  {binary, 1000000},
%%  {ets, 500000},
%%  {code, 3000000}]

%% 单个进程的详细信息
process_info(self(), [memory, heap_size, stack_size, message_queue_len]).

%% 系统内存信息
erlang:system_info(total_memory).

%% 查找内存占用最高的进程
top_processes() ->
    Procs = [{P, process_info(P, memory)} || P <- erlang:processes()],
    Sorted = lists:sort(fun({_, {_, M1}}, {_, {_, M2}}) -> M1 >= M2 end,
                        Procs),
    lists:sublist(Sorted, 10).

%% 检查消息队列堆积
check_mailboxes() ->
    Procs = [{P, process_info(P, message_queue_len)} || P <- erlang:processes()],
    [{P, Len} || {P, {_, Len}} <- Procs, Len > 100].

%% 手动触发 GC（调试用）
erlang:garbage_collect().               %% 当前进程
erlang:garbage_collect(Pid).           %% 指定进程
erlang:garbage_collect(self(), [{type, major}]). %% 完整 GC

%% GC 统计
{_, GcStats} = process_info(self(), garbage_collection).
io:format("GC count: ~p~n", [proplists:get_value(number_of_gcs, GcStats)]).

%% rebar.config 添加依赖
%% {deps, [{recon, "2.5.3"}]}.

%% 进程内存 Top N
recon:proc_count(memory, 10).

%% 消息队列 Top N
recon:proc_count(message_queue_len, 10).

%% 调用次数统计
recon:call_count({my_module, my_function, 1}, 5000).

%% 内存信息
recon:memory().

%% 获取端口信息
recon:inet_count(recv_oct, 10).

%% ❌ 列表拼接 O(n²)
lists:flatten([lists:reverse(T), [H]]).

%% ✅ cons 操作 O(1)
[H | T].

%% ❌ 频繁 ++ 操作
Result = List1 ++ List2 ++ List3.

%% ✅ IO List
Result = [List1, List2, List3].

%% ❌ 递归非尾调用
map(F, [H|T]) -> [F(H) | map(F, T)].

%% ✅ 尾递归 + 反转
map(F, L) -> map(F, L, []).
map(_F, [], Acc) -> lists:reverse(Acc);
map(F, [H|T], Acc) -> map(F, T, [F(H) | Acc]).

%% ❌ 频繁 list_to_binary
Binary = list_to_binary("prefix" ++ Data ++ "suffix").

%% ✅ 直接构造 binary
Binary = <<"prefix", Data/binary, "suffix">>.

%% 读多写少
ets:new(cache, [set, public, named_table, {read_concurrency, true}]).

%% 高写并发
ets:new(counters, [set, public, named_table, {write_concurrency, true}]).

%% 使用 compressed 节省内存
ets:new(big_table, [set, named_table, compressed]).

%% benchmark.erl
-module(benchmark).
-export([run/3, compare/2]).

%% 运行 N 次取平均
-spec run(fun(() -> term()), pos_integer(), string()) -> ok.
run(Fun, Times, Label) ->
    Results = [begin
        {T, _} = timer:tc(Fun),
        T
    end || _ <- lists:seq(1, Times)],
    
    Avg = lists:sum(Results) / length(Results),
    Min = lists:min(Results),
    Max = lists:max(Results),
    
    io:format("[~s] Avg: ~.2f μs, Min: ~p μs, Max: ~p μs~n",
              [Label, Avg, Min, Max]).

%% 比较两个实现
compare(Fun1, Fun2) ->
    Times = 10000,
    {T1, _} = timer:tc(fun() -> [Fun1() || _ <- lists:seq(1, Times)] end),
    {T2, _} = timer:tc(fun() -> [Fun2() || _ <- lists:seq(1, Times)] end),
    
    io:format("Fun1: ~p μs, Fun2: ~p μs, Ratio: ~.2f~n",
              [T1, T2, T1 / T2]).