comment utiliser erlang listes:fonction map

Ce qui suit est une erlang fonction. Je ne comprends pas comment faire des listes:carte fonction est utilisée ici.
Quelqu'un pourrait-il expliquer?

% perform M runs with N calls to F in each run.
% For each of the M runs, determine the average time per call.
% Return, the average and standard deviation of these M results.

time_it(F, N, M) ->
      G = fun() -> F(), ok end,
      NN = lists:seq(1, N),
      MM = lists:seq(1, M),
      T = lists:map(
            fun(_) ->
          T0 = now(),               % start timer
          [ G() || _ <- NN ],           % make N calls to F
          1.0e-6*timer:now_diff(now(), T0)/N    % average time per call
        end,
        MM
          ),
      { avg(T), std(T) }.

Grâce.

aussi, je ne connais pas la syntaxe correcte lors de l'utilisation de cette fonction. Par exemple, j'ai un dummy() prise de fonction 1 paramètre. J'obtiens une erreur lors de la tentative à la fois la fonction factice.

moduleName:time_it(moduleName:dummy/1, 10, 100).

ci-dessus permettrait d'évaluer à l'expression illégale.

En fait, maintenant, avec la syntaxe correcte, la fonction peut être appelée correctement avec:

moduleName:time_it(fun moduleName:dummy/1, 10, 100).

Cependant, il va lancer une exception dire l'invocation de la fonction factice sans passer n'importe quel paramètre. Je pense que cette ligne est le méchant, [ G() || _ <- NN ], je n'ai aucune idée de comment le résoudre.

Quelle est la raison pour G = fun() -> F(), ok end au lieu de le faire directement appel F() NN fois?
Mon estimation initiale était que c'était une erreur d'optimisation afin de "jeter" la sortie de F() dans le cas accumuler dans la compréhension de liste il a ralenti les choses. Donc je l'ai essayé et cela fait une différence! Si votre F sorties quelque chose comme une liste de 255 entiers, puis en exécutant un certain nombre de fois est plus lent à l'intérieur d'une compréhension de liste de l'appel de G(). C'est peut-être en raison de la surcharge de la constitution de la liste. À l'aide de listes:foreach est une meilleure solution - c'est beaucoup plus rapide que la compréhension de liste, et pas besoin de nid de la fonction.

OriginalL'auteur Quincy | 2009-10-10

erlang

6

map est ici utilisée pour exécuter la fonction
```
T0 = now(),                           % start timer
[ G() || _ <- NN ],                   % make N calls to F
1.0e-6*timer:now_diff(now(), T0)/N    % average time per call
```
pour chaque élément de MM. map sera de retour une nouvelle liste de la même taille, où chaque élément de la liste est le résultat de l'application de la fonction ci-dessus à l'élément correspondant de MM.

Vous pouvez invoquer time_it comme:
```
moduleName:time_it(fun moduleName:dummy/1, 10, 100).
```
OriginalL'auteur sepp2k
4

Le but de lists:map dans le time_it la fonction est d'exécuter la fonction interne M fois. Lorsque vous voyez ce modèle:
```
L = lists:seq(1,M),
lists:map(fun(_)-> Foo() end, L)
```
Cela signifie simplement appeler Foo() encore et encore, M temps, et de retourner les résultats de chaque appel dans une liste. Il est en fait une liste d'entiers [1,2,3,...N] et appelle ensuite Foo() une fois pour chaque membre de la liste.

L'auteur de time_it cette même truc nouveau, parce que time_it besoins à l'appel de la fonction que vous donnez, il N*M fois. Donc à l'intérieur que l'extérieur de la boucle qui s'exécute M fois qu'ils utilisent une technique différente pour exécuter la boucle interne N fois:
```
L = lists:seq(1,N),
[Foo() || _ <- L]
```
Ce qui a exactement le même résultat que le code ci-dessus, mais cette fois Foo s'appelle N fois.

La raison pour laquelle vous rencontrez des problèmes à l'aide de time_it avec votre fonction factice, c'est que time_it prend une fonction avec 0 paramètres, et non pas 1. Si vous avez besoin de faire un mannequin de la fonction et de l'appeler comme ceci:
```
dummy() -> 
    %% do something here you want to measure
    ok.

measure_dummy() ->
    time_it(fun someModule:dummy/0, 10, 100).
```
OriginalL'auteur Rob Charlton
1

Si vous avez une fonction moduleName:mannequin/1 vous pouvez effectuer l'une des opérations suivantes
1. Si vous pouvez modifier time_it/3, puis faire appel F(constant_parameter) au lieu de F(). Je suppose que c'est le cas.
2. Sinon, appelez M1:time_it(fun() -> M2:dummy(constant_parameter) end, N, M).
  mannequin ne sera pas appelé directement, mais seulement par F à l'intérieur de time_it.
OriginalL'auteur andi5

results(N, F) when N >= 0 -> results(N, F, []).
results(0, _, Acc) -> lists:reverse(Acc);
results(N, F, Acc) -> results(N-1, F, [F() | Acc]).

repeat(0, F) -> ok;
repeat(N, F) when N > 0 ->
    F(),
    repeat(N-1, F).

Avec ces:

T = results(M, fun () ->
                   T0 = now(),
                   repeat(N, G),
                   1.0e-6 * timer:now_diff(now(), T0)/N
               end)

Sens, maintenant?

OriginalL'auteur ayrnieu

Vous devez vous connecter pour publier un commentaire.