[mercury-users] What Triggers a GC?

[Ralph Becket]

Back on this benchmarking thing...  I've getting fluctuating results.  At
one point (using rotd-08-13 I think) I was getting within a factor of
2.4 or so of the speed of the C implementation.  Now, using rotd-10-17,
I'm down to about 3.2, or 2.9 if I'm willing to turn GC off (which is
probably cheating).  Most odd.  A factor of three is *not bad at all*
though, chaps'n'chapesses.  [The nice thing is that the simple-then-
evolved version runs faster than the directish transliteration of the C].

Anyway, io__report_stats told me that 4 MBytes of heap had been used and
7 odd GCs had taken place.  This really is surprising to me because I've
gone to some lengths to make sure the code doesn't allocate any memory.  So
I popped the code through the profiler, trying to find where this memory is
going, but no dice - mprof agrees with me that nothing is being allocated
(and I've checked that I'm not using any of the mprof-invisible predicates
Fergus listed a couple of weeks ago).  So what causes a GC to take place?

Either way, I'm writing up the results now because I want to put this
project
to bed.  However, if any of the Mercury developers could spare a little time
to look over the code and see where the time is going, I'd be very
interested
to hear their conclusions (+ put names on the paper).  The code is only 130
lines or so of active source.

It seems to me that, for carefully written code, there shouldn't be *that*
much difference between what a C compiler and what the Mercury
(or any similar strict declarative language) compiler produce.  Looking at
the C produced by the Mercury compiler, there is an *awful* lot of register
rearranging going on and some inlining that one might expect doesn't seem
to be happening.  For example, a little bit of code like

set_code(Codes0, Hash, Key, Code) = Codes :-
        Codes1 = array__set(Codes0, Hash, Key),
        Codes  = array__set(Codes1, Hash + hash_table_size, Code).

which I would expect to compile to just a handful of instructions (with
array
bounds checking turned off), along the lines of

	  Codes0[Hash] = Key;
        Codes0[Hash + hash_table_size] = Code;
        Codes = Codes0;

but it actually compiles to

/* code for predicate 'set_code'/5 in mode 0 */
Define_static(mercury__fn__compress__set_code_4_0);
        MR_incr_sp_push_msg(3, "compress:set_code/5");
        MR_stackvar(3) = (Word) MR_succip;
        MR_stackvar(2) = r4;
        r4 = r3;
        r3 = r2;
        MR_stackvar(1) = r2;
        r2 = r1;
        r1 = (Word) (Word *) &mercury_data___type_ctor_info_int_0;
        call_localret(ENTRY(mercury__fn__array__set_3_0),
                mercury__fn__compress__set_code_4_0_i2,
                STATIC(mercury__fn__compress__set_code_4_0));
Define_label(mercury__fn__compress__set_code_4_0_i2);
 
update_prof_current_proc(LABEL(mercury__fn__compress__set_code_4_0));
        r2 = r1;
        r1 = (Word) (Word *) &mercury_data___type_ctor_info_int_0;
        r3 = ((Integer) MR_stackvar(1) + (Integer) 69001);
        r4 = MR_stackvar(2);
        MR_succip = (Code *) MR_stackvar(3);
        MR_decr_sp_pop_msg(3);
        tailcall(ENTRY(mercury__fn__array__set_3_0),
                STATIC(mercury__fn__compress__set_code_4_0));

and there's no sign of this being inlined.  It may just be me totally
misunderstanding what's going on/what is necessary, but I'd really like
to know.

Cheers,

Ralph
--------------------------------------------------------------------------
mercury-users mailing list
post:  mercury-users at cs.mu.oz.au
administrative address: owner-mercury-users at cs.mu.oz.au
unsubscribe: Address: mercury-users-request at cs.mu.oz.au Message: unsubscribe
subscribe:   Address: mercury-users-request at cs.mu.oz.au Message: subscribe
--------------------------------------------------------------------------