efficiency of functions

[chaos]

Want something done right, do it yourself...

Code:

> eval object array inside; for(int ix = 0; ix < 1000; ix++) { inside = ({}); foreach(object who : users()) { object who_env = environment(who); if(who_env && who_env->query_terrain(Terrain_Building)) inside += ({ who }); } } return inside;
[ Result    : ] [Array] 6:
                  [Object] /usr/takoror (/usr/atman/grundy) (Takoror)
                  [Object] /usr/protax (/usr/atman/jensendied) (Protax)
                  [Object] /usr/clericon (/usr/atman/deomer) (Clericon)
                  [Object] /usr/morgana (/usr/atman/oboklob) (Morgana)
                  [Object] /usr/grumpy (/usr/atman/chadnoe) (Grumpy)
                  [Object] /usr/dyne (/usr/atman/cyrus) (Dyne)
[ Eval Cost : ] 2135023
[ Exec Time : ] 0.106469 sec
[ Compile   : ] 0.144924 sec

Code:

> eval object array inside; for(int ix = 0; ix < 1000; ix++) inside = filter(users(), (: object who_env = environment($1); return who_env && who_env->query_terrain(Terrain_Building); :)); return inside
[ Result    : ] [Array] 6:
                  [Object] /usr/takoror (/usr/atman/grundy) (Takoror)
                  [Object] /usr/protax (/usr/atman/jensendied) (Protax)
                  [Object] /usr/clericon (/usr/atman/deomer) (Clericon)
                  [Object] /usr/morgana (/usr/atman/oboklob) (Morgana)
                  [Object] /usr/grumpy (/usr/atman/chadnoe) (Grumpy)
                  [Object] /usr/dyne (/usr/atman/cyrus) (Dyne)
[ Eval Cost : ] 2035021
[ Exec Time : ] 0.110267 sec
[ Compile   : ] 0.140591 sec

I had it do the loop 1000 times to amplify the picture, since one pass took about a tenth of a millisecond.

Conclusion: the explicit loop is about 3.5% faster than a filter() in this instance.  Wodan's version that refrains from using += on an array will probably be faster yet; I would test it if I had any interest in packing all that into an eval.

Note that it achieves this faster speed while costing more LP eval units.  This is one of the many, many illustrations available of why eval units are good for one thing only, the eval limit (and they're barely good for that).

So, yeah.  This is enough speed difference to worry about in situations where you're already worrying about speed.

[zortek]

Forest and trees.

[cratylus]

Liver and onions.

[Nulvect]

Using wodan's version with no += and using time_expression gives me this:

Code:

eval return time_expression { object *inside = allocate(sizeof(users())); object pl, env; int i=0; foreach (pl in users()) { env = environment(pl); if (env && env->query_property("indoors")) inside[i++] = pl; } inside = inside[0..i-1]; write(identify(inside)+"\n"); }

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 243

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 205

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 222

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 220

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 235

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 221

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 220

Code:

eval return time_expression { object *inside = filter(users(), (: environment($1) && environment($1)->query_property("indoors") :) ); write(identify(inside)+"\n"); }

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 212

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 217

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 217

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 215

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 206

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 214

({ OBJ(uzamaki /std/user#1), OBJ(cyan /std/user#991), OBJ(geddoe /std/user#5375), OBJ(nulvect
/std/user#6247) })

Result = 216

That's 7 runs each. With filter had an average of 213 microseconds, without had an average of 223. I guess my driver is just weird; I understand that this is supposed to be abnormal... Either way though, I'm not going to worry about 10 microseconds.

[wodan]

try larger arrays

[Nulvect]

I tried it with testing each of objects() for ->is_weapon(), sizeof(objects()) == 2974. There are 365 weapons loaded. 7 passes of each again, filter averaged 4646 and foreach averaged 5146 microseconds.

I know I am probably sounding argumentative, but I'm really not trying to be. I'm very interested in making my code as efficient as possible, so I just like to know these things. Any ideas why my driver seems to be so odd??


The evals I typed, one right after the other (but formatted so they are readable):

Code:

eval int total=0; int *times = allocate(7);
for (int j = 0; j < 7; j++) {
  times[j] = time_expression {
    object *weapons = allocate(sizeof(objects()));
    object ob; int i=0;
    foreach (ob in objects())
      if (ob->is_weapon())
        weapons[i++] = ob;
    weapons = weapons[0..i-1];
    write(sizeof(weapons)+"\n");
  };
  total += times[j];
}
return total/7;

//---

eval int total=0; int *times = allocate(7);
for (int j = 0; j < 7; j++) {
  times[j] = time_expression {
    object *weapons = filter(objects(), (: $1->is_weapon() :) );
    write(sizeof(weapons)+"\n");
  };
  total += times[j];
}
return total/7;

[chaos]

I'd be interested in knowing what sorts of results you get using my code (the plain old += version) rather than Wodan's with the pre-allocate.

Pre-allocating sizeof(objects()) seems pretty scary to me...

[wodan]

I'd love to know what is scary about that. Anyway if for some weird reason filter is faster, in this case you're still doing it wrong 

object *weapons = filter(objects(), (: $1->is_weapon() );

is shorter and at least in theory faster when written as
object *weapons = objects( (: $1->is_weapon() );

This functionality of objects() is quite handy when you have more objects than your max array size

[Nulvect]

Ah, cool. I never use objects() so I didn't know it could do that.

[detah]

PLEASE use the code tags.
Ironically, it is the pound sign button right above the row of smilies in the text box.

[chaos]

Wodan: it's scary because objects(), in my world at least, is pretty damned large.  So it's scary in that it's more likely to break array limit than other methods (irrelevantly to performance) and is more likely to trigger an sbrk() than other methods (relevantly to performance).

Nulvect: Eval test?  Pretty please?  I could theorize about what's going on in differences between our drivers, but I'd like an apples-to-apples comparison first.

[Tricky]

Ah, cool. I never use objects() so I didn't know it could do that.

You can actually do that with any array of objects.

Code:

object *nonidle = filter(users(), (: query_idle($1) < 60 :) );
string *names = nonidle->GetKeyName(); /* DS lib specific. */

Tricky

[chaos]

Pretty sure he meant the form of objects() where you pass it the filter.