Petición de creación de una función de medida de tiempo de instrucciones tol

[lmperez@…]

Hola tol, ¿podríais incluir la siguiente función en la stdlib?
Mide el tiempo medio que tarda una instrucción tol en ejecutarse, independientemente de la gramática.
Creo que puede ser muy útil a la hora de optimizar el tiempo de las tareas de los proyectos.
Gracias de antemano.

//////////////////////////////////////////////////////////////////////////////
Real TolCode.Performance(Text code, Text grammar, Real n)
//////////////////////////////////////////////////////////////////////////////
{
  Real n2       = Floor(n);
  Set  codeW    = [[ "" ]];
  Set  grammarW = [[
    "Anything", "Code", "Complex", "CDate", "CTimeSet", "Date", "Matrix",
    "NameBlock", "Polyn", "Ratio", "Real", "Serie", "Set", "Special",
    "Struct", "Text", "TimeSet", "VMatrix", "Class", "\#Embed", "\#Require",
    "Static"
  ]];

  Real c.ok = If(code<:codeW,False,True);
  Real g.ok = If(grammar<:grammarW,True,False);
  Real n.ok = If(GE(n2,1),True,False);

  Real Case(And(c.ok,g.ok,n.ok),
  {
    Text txt.code =
    "Real time = Time; "+NL+
    "Set For(1,"+IntText(n2)+",Real (Real j) "+NL+
    "{ "+NL+
    "  "+grammar+" "+code+"; "+NL+
    "  Real True "+NL+
    "}); "+NL+
    "Real Time-time";
  
    Real time.routine    = Eval (txt.code);
    Real time.subroutine = time.routine/n;
    Real time.subroutine
  },
  Not(g.ok),
  {
    WriteLn("[TolCode.Performance] Not valid tol grammar.","W");
    Real False
  },
  Not(c.ok),
  {
    WriteLn("[TolCode.Performance] Not valid tol code function.","W");
    Real False
  },
  Not(n.ok),
  {
    WriteLn("[TolCode.Performance] Not valid number of simulations.","W");
    Real False
  },
  True,True)
};
//////////////////////////////////////////////////////////////////////////////
PutDescription("It measures the average time that a tol instruction takes to 
execute. It needs the instruction to execute as a text variable, the grammar
of the instruction and a number of simulations.",
TolCode.Performance);
//////////////////////////////////////////////////////////////////////////////

[Víctor de Buen Remiro]

Lo primero de todo es que en este tipo de cosas es muy difícil separar qué parte del tiempo se lleva la función, qué parte se lleva el lenguaje y qué parte se lleva el propio medidor.

No obstante seguro que la que propones puede ser útil cuando la función tiene un coste significativo, pongamos de décimas o centésimas de segundo. Si estuviéramos hablando de una escala menor, quizás de diezmilésimas de segundo, entonces no habría que hacer demasiado caso a la medición.

Por eso las funciones de profiling suelen ponerse en el núcleo C++. Quizás te interese saber que existe un método de medición del tiempo de todas las funciones que se ejecutan en un proceso TOL que consiste simplemente en lo siguiente

Real TolOprProfiler.Enabled := True;
//Insert code to perform
Real TolOprProfiler.Dump("result_path");

Eso creará un archivo de texto que se puede abrir con microsoft excel u openoffice calc y que contiene información del tiempo empleado por cada función. También saca otro fichero con el número de llamadas entre funciones. Hay que tener en cuenta que el tiempo incluye la evaluación de los argumentos, por lo que la suma no es el tiempo total sino mucho mayor, pero sirve para hacerse la idea de dónde se está gastando el tiempo para ver qué cosas merece la pena optimizar.

En todo caso creo que sería mejor crear un paquete de utilidades de programación porque bastante paja hay ya en la StdLib, que lo que hay que hacer es partirla en paquetes, como para meter más cosas. Esto es algo que habría que discutir entre todos con calma.