← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to lib/megaco/examples/meas/megaco_codec_meas.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-08-05 20:54:29 UTC
  • mfrom: (6.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090805205429-pm4pnwew8axraosl
Tags: 1:13.b.1-dfsg-5
http://bugs.debian.org/536891
* Fixed parentheses in Emacs mode (closes: #536891).
* Removed unnecessary conflicts with erlang-manpages package.
* Added workaround for #475459: disabled threads on sparc architecture.
  This breaks wxErlang, so it's only a temporary solution.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/megaco/examples/meas/megaco_codec_meas.erl
43
43
 
44
44
 
45
45
%% API
46
 
-export([t/0, t1/0, t/1]).
47
 
-export([te/0,
48
 
         tb/0, tbb/0, tbp/0,
49
 
         tt/0, ttp/0, ttc/0]).
 
46
-export([start/0, start/1]).
 
47
-export([start1/0]).
50
48
 
51
49
%% Internal exports
52
50
-export([do_measure_codec/7, do_measure_codec_loop/7]).
68
66
-endif.
69
67
 
70
68
-ifndef(MEASURE_CODECS).
71
 
-define(MEASURE_CODECS, [pretty, compact, per, ber, erlang]).
72
 
%% -define(MEASURE_CODECS, [pretty, compact]).
 
69
-define(MEASURE_CODECS, megaco_codec_transform:codecs()).
73
70
-endif.
74
71
 
75
 
-record(stat, {file, ecount, etime, dcount, dtime, size}).
 
72
-define(DEFAULT_MESSAGE_PACKAGE, megaco_codec_transform:default_message_package()).
 
73
 
 
74
-record(stat, {name, ecount, etime, dcount, dtime, size}).
76
75
 
77
76
 
78
77
%% Runs the measurement on all "official" codecs
79
78
 
80
 
t1() ->
 
79
start1() ->
81
80
    put(everbose,true),
82
 
    t().
83
 
 
84
 
t() ->
85
 
    t(?MEASURE_CODECS).
86
 
 
87
 
te() ->
88
 
    t([erlang]).
89
 
 
90
 
tb() ->
91
 
    t([ber, per]).
92
 
 
93
 
tbb() ->
94
 
    t([ber]).
95
 
 
96
 
tbp() ->
97
 
    t([per]).
98
 
 
99
 
tt() ->
100
 
    t([pretty, compact]).
101
 
 
102
 
ttp() ->
103
 
    t([pretty]).
104
 
 
105
 
ttc() ->
106
 
    t([compact]).
 
81
    start().
 
82
 
 
83
start() ->
 
84
    meas_init(?DEFAULT_MESSAGE_PACKAGE, ?MEASURE_CODECS).
 
85
 
 
86
start([MessagePackage]) ->
 
87
    do_start(MessagePackage, ?MEASURE_CODECS);
 
88
start(MessagePackage) ->
 
89
    do_start(MessagePackage, ?MEASURE_CODECS).
 
90
 
 
91
do_start(MessagePackageRaw, Codecs) ->
 
92
    MessagePackage = parse_message_package(MessagePackageRaw), 
 
93
    meas_init(MessagePackage, Codecs).
 
94
    
 
95
parse_message_package(MessagePackageRaw) when is_list(MessagePackageRaw) ->
 
96
    list_to_atom(MessagePackageRaw);
 
97
parse_message_package(MessagePackage) when is_atom(MessagePackage) ->
 
98
    MessagePackage;
 
99
parse_message_package(BadMessagePackage) ->
 
100
    throw({error, {bad_message_package, BadMessagePackage}}).
107
101
 
108
102
 
109
103
%% Dirs is a list of directories containing files,
116
110
%%    pretty | compact | ber | per | erlang
117
111
%%
118
112
 
119
 
t(Dirs) when list(Dirs) ->
 
113
meas_init(MessagePackage, Codecs) ->
120
114
    %% process_flag(trap_exit, true),
121
 
    io:format("~n", []),
 
115
    io:format("~nRun meas on message package: ~p~n~n", [MessagePackage]),
122
116
    display_os_info(),
123
117
    display_system_info(),
124
118
    display_app_info(),
125
119
    io:format("~n", []),
126
120
    Started = now(),
127
 
    EDirs = expand_dirs(Dirs, []),
128
 
    Results = t1(EDirs, []), 
129
 
    display_time(Started, now()),
130
 
    store_results(Results).
 
121
    case megaco_codec_transform:messages(MessagePackage) of
 
122
        Messages when is_list(Messages) ->
 
123
            ExpandedMessages = expand_messages(Codecs, Messages),
 
124
            Results = t1(ExpandedMessages, []), 
 
125
            display_time(Started, now()),
 
126
            store_results(Results);
 
127
        Error ->
 
128
            Error
 
129
    end.
131
130
 
132
131
display_os_info() ->
133
132
    V = case os:version() of
160
159
    MI = megaco:module_info(),
161
160
    {value, {attributes, Attr}} = lists:keysearch(attributes, 1, MI),
162
161
    {value, {app_vsn,    Ver}}  = lists:keysearch(app_vsn, 1, Attr),
163
 
    io:format("Megaco version:      ~s~n", [Ver]).
 
162
    FlexStr = 
 
163
        case megaco_flex_scanner:is_enabled() of
 
164
            true ->
 
165
                case megaco_flex_scanner:is_reentrant_enabled() of
 
166
                    true ->
 
167
                        "reentrant flex";
 
168
                    false ->
 
169
                        "non-reentrant flex"
 
170
                end;
 
171
            false ->
 
172
                "no flex"
 
173
        end,
 
174
    io:format("Megaco version:      ~s (~s)~n", [Ver, FlexStr]).
164
175
 
165
176
display_asn1_info() ->
166
177
    AI = megaco_ber_bin_drv_media_gateway_control_v1:info(),
167
178
    Vsn = 
168
179
        case lists:keysearch(vsn, 1, AI) of
169
 
            {value, {vsn, V}} when atom(V) ->
 
180
            {value, {vsn, V}} when is_atom(V) ->
170
181
                atom_to_list(V);
171
 
            {value, {vsn, V}} when list(V) ->
 
182
            {value, {vsn, V}} when is_list(V) ->
172
183
                V;
173
184
            _ ->
174
185
                "unknown"
216
227
                              
217
228
t1([], Results) ->
218
229
    lists:reverse(Results);
219
 
t1([{Dir, Codec, Conf, _} = EDir|Dirs], Results) ->
220
 
    case (catch measure(EDir)) of
 
230
t1([{Id, Codec, Conf, _, _} = ECodec|EMsgs], Results) ->
 
231
    case (catch measure(ECodec)) of
221
232
        {'EXIT', Reason} ->
222
233
            error("measure of codec ~p exited: ~n~p", [Codec, Reason]),
223
 
            t1(Dirs, Results);
 
234
            t1(EMsgs, Results);
224
235
        {error, Reason} ->
225
236
            error("skipping codec ~p: ~n~p", [Codec, Reason]),
226
 
            t1(Dirs, Results);
 
237
            t1(EMsgs, Results);
227
238
        {ok, Res} ->
228
 
            t1(Dirs, [{Dir, Conf, Res}| Results])
 
239
            t1(EMsgs, [{Id, Conf, Res}| Results])
229
240
    end.
230
241
 
231
242
 
232
 
measure({Dir, Codec, Conf, Count}) when list(Dir) ->
 
243
measure({Id, Codec, Conf, Count, Msgs}) ->
233
244
    io:format("measure using codec ~p ~p~n ", [Codec, Conf]),
234
245
    {Init, Conf1} = measure_init(Conf),
235
246
    Conf2 = [{version3,?V3}|Conf1],
236
 
    Res = measure(Dir, Codec, Conf2, read_files(Dir), [], Count),
 
247
    Res = measure(Id, Codec, Conf2, Msgs, [], Count),
237
248
    measure_fin(Init),
238
249
    Res.
239
250
 
240
251
 
241
 
expand_dirs([], EDirs) ->
242
 
    lists:reverse(lists:flatten(EDirs));
243
 
expand_dirs([Dir|Dirs], EDirs) when atom(Dir) ->
244
 
    EDir = expand_dir(atom_to_list(Dir)),
245
 
    expand_dirs(Dirs, [EDir|EDirs]);
246
 
expand_dirs([Dir|Dirs], EDirs) when list(Dir) ->
247
 
    EDir = expand_dir(Dir),
248
 
    expand_dirs(Dirs, [EDir|EDirs]).
249
 
 
250
 
expand_dir(Dir) ->
251
 
    case Dir of
252
 
        "pretty" ->
253
 
            [{Dir, megaco_pretty_text_encoder, [flex_scanner], 3000},
254
 
             {Dir, megaco_pretty_text_encoder, [],             1000}];
255
 
        "compact" ->
256
 
            [{Dir, megaco_compact_text_encoder, [flex_scanner], 3000},
257
 
             {Dir, megaco_compact_text_encoder, [],             1500}];
258
 
        "ber" ->
259
 
            [{Dir, megaco_ber_bin_encoder, [driver,native], 4000},
260
 
             {Dir, megaco_ber_bin_encoder, [native],        3000},
261
 
             {Dir, megaco_ber_bin_encoder, [driver],        3000},
262
 
             {Dir, megaco_ber_bin_encoder, [],              1000}];
263
 
        "per" ->
264
 
            [{Dir, megaco_per_bin_encoder, [driver,native], 4000},
265
 
             {Dir, megaco_per_bin_encoder, [native],        3000},
266
 
             {Dir, megaco_per_bin_encoder, [driver],        3000},
267
 
             {Dir, megaco_per_bin_encoder, [],              1000}];
268
 
        "erlang" ->
 
252
expand_messages(Codecs, Messages) ->
 
253
    ECodecs = expand_codecs(Codecs, []),
 
254
    expand_messages(ECodecs, Messages, []).
 
255
 
 
256
expand_messages([], _, EMessages) ->
 
257
    lists:reverse(EMessages);
 
258
expand_messages([{Id, Codec, Conf, Count} | ECodecs], Messages, EMessages) ->
 
259
    case lists:keysearch(Id, 1, Messages) of
 
260
        {value, {Id, Msgs}} ->
 
261
            expand_messages(ECodecs, Messages, 
 
262
                            [{Id, Codec, Conf, Count, Msgs}|EMessages]);
 
263
        false ->
 
264
            exit({error, {no_such_codec_data, Id}})
 
265
    end.
 
266
 
 
267
expand_codecs([], ECodecs) ->
 
268
    lists:reverse(lists:flatten(ECodecs));
 
269
expand_codecs([Codec|Codecs], ECodecs) when is_atom(Codec) ->
 
270
    ECodec = expand_codec(Codec),
 
271
    expand_codecs(Codecs, [ECodec|ECodecs]).
 
272
 
 
273
expand_codec(Codec) ->
 
274
    case Codec of
 
275
        pretty ->
 
276
            [{Codec, megaco_pretty_text_encoder, [flex_scanner], 2000},
 
277
             {Codec, megaco_pretty_text_encoder, [],             1000}];
 
278
        compact ->
 
279
            [{Codec, megaco_compact_text_encoder, [flex_scanner], 3000},
 
280
             {Codec, megaco_compact_text_encoder, [],             1500}];
 
281
        ber ->
 
282
            [{Codec, megaco_ber_bin_encoder, [driver,native], 4000},
 
283
             {Codec, megaco_ber_bin_encoder, [native],        3000},
 
284
             {Codec, megaco_ber_bin_encoder, [driver],        3000},
 
285
             {Codec, megaco_ber_bin_encoder, [],              1000}];
 
286
        per ->
 
287
            [{Codec, megaco_per_bin_encoder, [driver,native], 4000},
 
288
             {Codec, megaco_per_bin_encoder, [native],        3000},
 
289
             {Codec, megaco_per_bin_encoder, [driver],        3000},
 
290
             {Codec, megaco_per_bin_encoder, [],              1000}];
 
291
        erlang ->
269
292
            [
270
 
             {Dir, megaco_erl_dist_encoder, [megaco_compressed,compressed], 500},
271
 
             {Dir, megaco_erl_dist_encoder, [compressed], 400},
272
 
             {Dir, megaco_erl_dist_encoder, [megaco_compressed], 10000},
273
 
             {Dir, megaco_erl_dist_encoder, [], 10000}
 
293
             {Codec, megaco_erl_dist_encoder, [megaco_compressed,compressed], 500},
 
294
             {Codec, megaco_erl_dist_encoder, [compressed], 400},
 
295
             {Codec, megaco_erl_dist_encoder, [megaco_compressed], 10000},
 
296
             {Codec, megaco_erl_dist_encoder, [], 10000}
274
297
            ];
275
298
        Else ->
276
299
            exit({error, {invalid_codec, Else}})
277
300
    end.
278
301
 
279
302
 
280
 
read_files(Dir) ->
281
 
    case file:list_dir(Dir) of
282
 
        {ok, Files} ->
283
 
            lists:sort(Files);
284
 
        Error ->
285
 
            exit(Error)
286
 
    end.
287
 
 
288
303
measure_init([flex_scanner]) ->
289
304
    start_flex_scanner();
290
305
measure_init(Conf) ->
291
306
    {undefined, Conf}.
292
307
 
293
308
 
294
 
measure_fin(Pid) when pid(Pid) ->
 
309
measure_fin(Pid) when is_pid(Pid) ->
295
310
    stop_flex_scanner(Pid),
296
311
    ok;
297
312
measure_fin(_) ->
315
330
 
316
331
    {ok, lists:reverse(Res)};
317
332
 
318
 
measure(Dir, Codec, Conf, [File|Files], Results, MCount) ->
319
 
    io:format(" ~s", [File]),
320
 
    case (catch do_measure(Dir, Codec, Conf, File, MCount)) of
 
333
measure(Dir, Codec, Conf, [{Name, Bin}|Msgs], Results, MCount) ->
 
334
    io:format(" ~p", [Name]),
 
335
    case (catch do_measure(Dir, Codec, Conf, Name, Bin, MCount)) of
321
336
        {ok, Stat} ->
322
 
            measure(Dir, Codec, Conf, Files, [Stat | Results], MCount);
 
337
            measure(Dir, Codec, Conf, Msgs, [Stat | Results], MCount);
323
338
 
324
339
        {error, S} ->
325
 
            io:format("~n~s failed: ~n", [File]),
 
340
            io:format("~n~s failed: ~n", [Name]),
326
341
            error(S,[]),
327
 
            measure(Dir, Codec, Conf, Files, Results, MCount);
 
342
            measure(Dir, Codec, Conf, Msgs, Results, MCount);
328
343
 
329
344
        {info, S} ->
330
345
            case get(verbose) of
332
347
                    io:format("~n", []),
333
348
                    info(S,[]);
334
349
                _ ->
335
 
                    io:format("~n~s skipped~n", [File])
 
350
                    io:format("~n~s skipped~n", [Name])
336
351
            end,
337
 
            measure(Dir, Codec, Conf, Files, Results, MCount)
 
352
            measure(Dir, Codec, Conf, Msgs, Results, MCount)
338
353
 
339
354
    end.
340
355
 
341
356
 
342
 
do_measure(Dir, Codec, Conf, File, MCount) ->
343
 
    BinMsg             = read_message(Dir, File),
 
357
do_measure(_Id, Codec, Conf, Name, BinMsg, MCount) ->
344
358
    %% io:format("~n~s~n", [binary_to_list(BinMsg)]),
345
359
    {Version, NewBin}  = detect_version(Codec, Conf, BinMsg),
346
360
    {Msg, Dcnt, Dtime} = measure_decode(Codec, Conf, Version, NewBin, MCount),
347
361
    {_,   Ecnt, Etime} = measure_encode(Codec, Conf, Version, Msg, MCount),
348
362
 
349
 
    {ok, #stat{file = File, 
350
 
%              ecount = 1, etime = 1, 
351
 
%              dcount = 1, dtime = 1, 
 
363
    {ok, #stat{name   = Name, 
352
364
               ecount = Ecnt, etime = Etime, 
353
365
               dcount = Dcnt, dtime = Dtime, 
354
366
               size = size(NewBin)}}.
355
367
 
356
 
read_message(Dir, FileName) ->
357
 
    File = filename:join([Dir, FileName]),
358
 
    case file:read_file_info(File) of
359
 
        {ok, #file_info{size = Sz, type = regular}} when Sz > 0 ->
360
 
            case file:read_file(File) of
361
 
                {ok, Msg} ->
362
 
                    %% io:format(".", []),
363
 
                    Msg;
364
 
                {error, Reason} ->
365
 
                    S = format("failed reading file ~s: ~p", [File, Reason]),
366
 
                    throw({error, S})
367
 
            end;
368
 
 
369
 
        {ok, #file_info{type = regular}} ->
370
 
            S = format("skipping empty file ~s", [File]),
371
 
            throw({info, S});
372
 
 
373
 
        {ok, #file_info{type = Type}} ->
374
 
            S = format("skipping ~p file ~s", [Type, File]),
375
 
            throw({info, S});
376
 
 
377
 
        {ok, Info} ->
378
 
            S = format("skipping file ~s~n~p", [File, Info]),
379
 
            throw({info, S});
380
 
 
381
 
        {error, Reason} ->
382
 
            S = format("failed reading file info for ~s: ~p", [File, Reason]),
383
 
            throw({error, S})
384
 
 
385
 
    end.
386
 
 
387
 
 
388
368
detect_version(Codec, Conf, Bin) ->
389
369
    case (catch Codec:version_of(Conf, Bin)) of
390
370
        {ok, V} ->
572
552
 
573
553
store_excel_tab1(Fd, []) ->
574
554
    io:format(Fd, "~n", []);
575
 
store_excel_tab1(Fd, [{Dir, Conf, Avg, Values}|T]) when list(Conf) ->
 
555
store_excel_tab1(Fd, [{Dir, Conf, Avg, Values}|T]) when is_list(Conf) ->
576
556
    io:format(Fd, "~s~s (~w)", 
577
557
              [filename:basename(Dir), config_to_string(Conf), Avg]),
578
558
    store_excel_tab_row(Fd, Values),
580
560
 
581
561
config_to_string([]) ->
582
562
    "";
583
 
config_to_string([C]) when atom(C) ->
 
563
config_to_string([C]) when is_atom(C) ->
584
564
    io_lib:format("_~w", [C]);
585
 
config_to_string([C|Cs]) when atom(C) ->
 
565
config_to_string([C|Cs]) when is_atom(C) ->
586
566
    lists:flatten(io_lib:format("_~w", [C]) ++ config_to_string(Cs)).
587
567
 
588
568
store_excel_tab_header(Fd, 0, _) ->
621
601
 
622
602
flex_scanner_handler(Pid) ->
623
603
    case (catch megaco_flex_scanner:start()) of
624
 
        {ok, Port} when port(Port) ->
 
604
        {ok, Port} when is_port(Port) ->
625
605
            Pid ! {flex_scanner_started, self(), {flex, Port}},
626
606
            flex_scanner_handler(Pid, Port);
 
607
        {ok, Ports} when is_tuple(Ports) ->
 
608
            Pid ! {flex_scanner_started, self(), {flex, Ports}},
 
609
            flex_scanner_handler(Pid, Ports);
627
610
        {error, {load_driver, {open_error, Reason}}} ->
628
611
            Error = {failed_loading_flex_scanner_driver, Reason},
629
612
            Pid ! {flex_scanner_error, Error},
634
617
            exit(Error)
635
618
    end.
636
619
 
637
 
flex_scanner_handler(Pid, Port) ->
 
620
flex_scanner_handler(Pid, PortOrPorts) ->
638
621
    receive
639
622
        {ping, Pinger} ->
640
623
            Pinger ! {pong, self()},
641
 
            flex_scanner_handler(Pid, Port);
 
624
            flex_scanner_handler(Pid, PortOrPorts);
642
625
        {'EXIT', Port, Reason} ->
643
 
            Pid ! {flex_scanner_exit, Reason},
644
 
            exit({flex_scanner_exit, Reason});
 
626
            case megaco_flex_scanner:is_scanner_port(Port, PortOrPorts) of
 
627
                true ->
 
628
                    Pid ! {flex_scanner_exit, Reason},
 
629
                    exit({flex_scanner_exit, Reason});
 
630
                false ->
 
631
                    info("exit signal from unknown port ~p"
 
632
                         "~n   Reason: ~p", [Port, Reason]),
 
633
                    flex_scanner_handler(Pid, PortOrPorts)
 
634
            end;
645
635
        stop_flex_scanner ->
646
 
            megaco_flex_scanner:stop(Port),
 
636
            megaco_flex_scanner:stop(PortOrPorts),
647
637
            exit(normal);
648
638
        Other ->
649
639
            info("flex scanner handler got something:~n~p", [Other]),
650
 
            flex_scanner_handler(Pid, Port)
 
640
            flex_scanner_handler(Pid, PortOrPorts)
651
641
    end.
652
642
 
653
643