Re: [Ngspice-devel] Tiny patch

[Robert L. <Rob...@t-...>]

Matthew Guthaus <mr...@so...> writes:

> I noticed that when using a lot of .measure statements 70% of CPU time is spent comparing strings:
>
> Each sample counts as 0.01 seconds.
>  %   cumulative   self              self     total           
> time   seconds   seconds    calls   s/call   s/call  name    
> 70.67     25.16    25.16 1326020941     0.00     0.00  cieq
> 15.04     30.52     5.36  3104531     0.00     0.00  findvec
>  3.60     31.80     1.28   225037     0.00     0.00  com_measure_when
>  2.98     32.86     1.06                             scannum
>  1.52     33.40     0.54 19926865     0.00     0.00  spice_dstring_append
>  1.29     33.86     0.46  3209201     0.00     0.00  gettok
>  0.96     34.20     0.34     1468     0.00     0.00  BSIM4v2load
>  0.34     34.32     0.12  6886171     0.00     0.00  tmalloc
>  0.31     34.43     0.11 19857822     0.00     0.00  spice_dstring_append_char
>  0.31     34.54     0.11   826248     0.00     0.00  vec_fromplot
>  0.20     34.61     0.07      726     0.00     0.05  do_measure
>  0.17     34.67     0.06  4050975     0.00     0.00  copy
>  0.17     34.73     0.06   302432     0.00     0.00  CKTterr
>  0.17     34.79     0.06   200376     0.00     0.00  measure_parse_line
>  0.17     34.85     0.06                             spSolve
>
>
> This simple patch reduces that to 50%.  Working on avoiding the string comparison completely...
>
> Index: src/misc/string.c
> ===================================================================
> RCS file: /cvsroot/ngspice/ngspice/ng-spice-rework/src/misc/string.c,v
> retrieving revision 1.16
> diff -u -p -r1.16 string.c
> --- src/misc/string.c   11 Apr 2010 08:49:05 -0000      1.16
> +++ src/misc/string.c   26 May 2010 15:20:08 -0000
> @@ -100,12 +100,12 @@ scannum(char *str)
>  /* Case insensitive str eq. */
>  /* Like strcasecmp( ) XXX */
>  
> -int
> +inline int
>  cieq(register char *p, register char *s)
>  {
>      while (*p) {
> -        if ((isupper(*p) ? tolower(*p) : *p) !=
> -            (isupper(*s) ? tolower(*s) : *s))
> +        if (tolower(*p)!=
> +            tolower(*s))
>              return(FALSE);
>          p++;
>          s++;
> @@ -119,8 +119,8 @@ int
>  ciprefix(register char *p, register char *s)
>  {
>      while (*p) {
> -        if ((isupper(*p) ? tolower(*p) : *p) !=
> -            (isupper(*s) ? tolower(*s) : *s))
> +        if (tolower(*p)!=
> +            tolower(*s))
>              return(FALSE);
>          p++;
>          s++;

Hello Matthew,

  Can you help me to understand this better ?

  Your patch has two aspects :
    1) the inline declaration
    2) the reduction of actuall work by using the simpler
         tolower!=tolower expression

  Your grproff log  has a third aspect
    a very sick high number of cieq call's (1e9 !!)

  The inline should'nt do much, it would apply only to the invokers of the
    function in the exact same .c file. all others would still do a
    real function call.
  But it might hide something in the successive gproff report,
    the amount of CPU time will pop up in another function.

  The tolower!=tolower saves a bit of work, is nicer anyway, ok

  But the reall thing is the really sick number of cieq calls.

  Can you take the time to assemble a really small piece of .cir file
    which demonstrates such a high amount of measure related cieq calls ?
  I suppose there is something implemented very inefficient,
    and this would help to find out what it is.

Thank You,
  Robert Larice