From: Andy Wingo <wingo@pobox.com>
To: Mark H Weaver <mhw@netris.org>
Cc: "Ludovic Courtès" <ludo@gnu.org>, guile-devel@gnu.org
Subject: Re: Register VM WIP
Date: Wed, 16 May 2012 16:58:24 +0200 [thread overview]
Message-ID: <87r4uki35b.fsf@pobox.com> (raw)
In-Reply-To: <87sjf09r5v.fsf@netris.org> (Mark H. Weaver's message of "Wed, 16 May 2012 09:44:28 -0400")
Howdy,
On Wed 16 May 2012 15:44, Mark H Weaver <mhw@netris.org> writes:
>> The design of the wip-rtl VM is to allow 16M registers (24-bit
>> addressing). However many instructions can just address 2**8 registers
>> (8-bit addressing) or 2**12 registers (12-bit addressing). We will
>> reserve registers 253 to 255 as temporaries. If you have so many
>> registers as to need more than that, then you have to shuffle operands
>> down into the temporaries. That's the plan, anyway.
>
> I'm very concerned about this design, for the same reason that I was
> concerned about NaN-boxing on 32-bit platforms. Efficient use of memory
> is extremely important on modern architectures, because of the vast (and
> increasing) disparity between cache speed and RAM speed. If you can fit
> the active set into the cache, that often makes a profound difference in
> the speed of a program.
>
> I agree that with VMs, minimizing the number of dispatches is crucial,
> but beyond a certain point, having more registers is not going to save
> you any dispatches, because they will almost never be used anyway.
> 2^12 registers is _far_ beyond that point.
I'm probably not explaining myself clearly. Here goes.
I willingly grant that 256 registers is usually enough. But there are
valid reasons to use 2**12 registers: for example in the mov
instruction, if you have an 8-bit opcode, you have 24 bits left. Using
12 for each operand makes sense. There are other cases in which you
want to reference 24-bit values, for relative jumps; and even 32-bit
values, to reference constants using relative addressing. (64 MB is too
small a limit for one compilation unit. 16 GB is fine.)
Likewise I can imagine cases in which you might end up with more than
2**12 active locals, especially in the presence of macros. In that case
you spill. But where do you spill? For Guile, this means spilling to
additional registers, and having to shuffle with long-mov. Otherwise
you would spill to a vector or something. The WIP-RTL strategy
adequately captures the edge case while making the normal case fast.
> If I were designing this VM, I'd work hard to allow as many loops as
> possible to run completely in the cache. That means that three things
> have to fit into the cache together: the VM itself, the user loop code,
> and the user data. IMO, the sum of these three things should be made as
> small as possible.
Certainly.
> I certainly agree that we should have a generous number of registers,
> but I suspect that the sweet spot for a VM is 256, because it enables
> more compact dispatching code in the VM, and yet is more than enough to
> allow a decent register allocator to generate good code.
>
> That's my educated guess anyway. Feel free to prove me wrong :)
I will do better: I will prove you right and prove me right at the same
time :) The instructions in wip-rtl try to stay in one 32-bit unit. In
that case they have limits, usually 8 bits. But when they need to
"spill", they will do so on the stack, not on the heap.
Regards,
Andy
--
http://wingolog.org/
next prev parent reply other threads:[~2012-05-16 14:58 UTC|newest]
Thread overview: 20+ messages / expand[flat|nested] mbox.gz Atom feed top
2012-05-11 16:19 Register VM WIP Andy Wingo
2012-05-11 20:29 ` Stefan Israelsson Tampe
2012-05-16 15:01 ` Andy Wingo
2012-05-14 21:09 ` Ludovic Courtès
2012-05-14 21:28 ` Andrew Gwozdziewycz
2012-05-15 18:45 ` Andy Wingo
2012-05-16 0:39 ` Noah Lavine
2012-05-16 4:23 ` Mark H Weaver
2012-05-16 7:15 ` Andy Wingo
2012-05-16 13:44 ` Mark H Weaver
2012-05-16 14:00 ` David Kastrup
2012-05-16 14:54 ` Noah Lavine
2012-05-16 15:05 ` Andy Wingo
2012-05-16 20:39 ` Ludovic Courtès
2012-05-16 14:58 ` Andy Wingo [this message]
2012-05-16 16:27 ` Mark H Weaver
2012-05-16 16:39 ` Andy Wingo
2012-05-16 18:23 ` Noah Lavine
2012-05-16 7:10 ` Andy Wingo
2012-05-15 18:49 ` Andy Wingo
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
List information: https://www.gnu.org/software/guile/
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=87r4uki35b.fsf@pobox.com \
--to=wingo@pobox.com \
--cc=guile-devel@gnu.org \
--cc=ludo@gnu.org \
--cc=mhw@netris.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).