Subject: RE: [rohc] WGLC comments to torture-tests and user-guide

From: "Surtees, Abigail" <[email-masked]>
Date: Thu, 25 Aug 2005 16:27:42 +0100

Hi Pekka, Cristian, all,

It would be really good if we could reach consensus on this, so that I
can update and re-issue the draft.  Please see Mark's email below and
also from my original numbering scheme:

1) there are no heuristics, use of '!' is explicit.  It is a simple
solution which makes it particularly useful for anyone arriving new to
the concept of translating mnemonic code, but means that those of us who
already have translators will have to update them.

2) there are explicit heuristics.  We've currently all implemented our
own heuristics, so reaching a consensus on what the heuristics should be
is likely to take quite a while.  It also adds complexity to what is, at
the end of the day, an informational document.

3) there is a statement that when you use '!' you have to be careful and
that if you want to use anything other than heuristics, readonly() is a
way to do it.  We can all carry on using our existing heuristics and
insert readonly() if we want.

In my humble opinion:
	1) is the simplest in terms of rigorous specification, hence I
like it; 
	2) will require more effort to specify it than I think it is
worth; 
	3) is not quite as intellectually satisfying as 1) but is a
simple way to specify use of readonly().

So I'd be happy with 1) or 3).  Given we've all already got heuristics
implemented, 3) seems the simplest [though I still like 1) :-) ].

Your comments and opinions would be appreciated so we can reach a
consensus.

Best regards,

Abbie

> 
> Hi Pekka, all,
> 
> I think that we failed to completely follow through on the 
> discussion of
> this issue when it was originally raised.  It comes down, I 
> believe, to a
> choice:
> 
> i) specifying the legitimate targets for '!' should be done explicitly
>    (see, e.g., Carsten's "strawman" proposal, in
>     http://www1.ietf.org/mail-archive/web/rohc/current/msg03660.html)
> 
> ii) the assembler is assumed to make use of sensible heuristics for
>     managing '!'; directives have been added to make life easier for
>     people who think that self-modifying code is pretty neat idea ;-)
>     (see, e.g. Carsten's suggested heuristic, in
>      http://www1.ietf.org/mail-archive/web/rohc/current/msg03662.html
>      corroborated by Adam)
> 
> So, on Abbie's list, option (1) corresponds pretty much 
> directly with (i),
> above -- you can't use '!' unless you have the appropriate directives.
> 
> Options (2) and (3) correspond with (ii), above -- you can 
> use '!', but
> either need good heuristics and/or appropriate directives.
> 
> The difference between options (2) and (3) is that (2) spells 
> out *what*
> the heuristics are and the interactions between these and the 
> directives.
> 
> Example:
> 
> 	ADD ($value, 1)
> 	JUMP (somewhere_else)
> 	readonly (0)
> 	byte (0x40)
> 	byte (0x41)
> 	:somewhere_else
> 	SUB ($value, 1)
> 
> When we go back into bytecode at ':somewhere_else', does this imply
> 'readonly(1)' or do we rely on explicit cues?  Is this 
> different (and in
> what way) from *not* having the directive and using the 'only 
> code can be
> a target for "!"' heuristic?  Option (2) has to nail these 
> things down.
> 
> Option (3) says that we assume everything carries on the same way as
> before, but there are now some additional directives.  You can use
> whatever heuristics you like *but* you are absolutely *not* allowed to
> make use of any bytes between a readonly(1)/readonly(0) pair 
> as a target
> for '!'.
> 
> Personally, I like (1) or (3). (1) is simple (you have to put
> directives in; no need for smarts in the assembler).  (3) 
> means that I can
> continue to use the heuristics I've already coded up, but 
> adds support for
> the directives if someone ever throws self-modifying code in 
> my direction.
> (2) will lead, I suspect, to more wrangling over which heuristics to
> specify, etc...
> 
> Given I've got a working assembler, I think I'd lean towards 
> (3), but I'm
> not too bothered [and I know Abbie & I disagree on this one :-)]
> 
> Cheers,
> 
> Mark.
> 
> 
> 
> 

_______________________________________________
Rohc mailing list
[email-masked]
https://www1.ietf.org/mailman/listinfo/rohc

---

From: Pekka Pessi <[email-masked]>
Date: Tue, 30 Aug 2005 11:56:30 +0300

>Your comments and opinions would be appreciated so we can reach a

I'm fine with 1-2-3 (as long as the famous someone else gives the
required effort ;) but IMO 3) would be best pick in this point.

--Pekka

---

From: Cristian CONSTANTIN <[email-masked]>
Date: Tue, 30 Aug 2005 12:31:43 +0200

> 	1) is the simplest in terms of rigorous specification, hence I

cristian: the most radical solution. the problem is that all the
examples using ! have to be changed, tested, blah, blah...

> 	2) will require more effort to specify it than I think it is

cristian: as I have said, IMHO specifing heuristics is too much for an
rfc. most of the rfc I have read do not go into such details. 
I would not do it.

> simple way to specify use of readonly().

cristian: it is a compromise which seems to be in this case also the
best solution.

so, I'd choose 3.

cristian
bye now!
-- 
 _          | There are many people who use UNIX or Linux  
(_'_        | who IMHO do not understand UNIX.
  (_'rist   |              --David Korn  
GPG public key at wwwkeys.de.pgp.net
_______________________________________________
Rohc mailing list
[email-masked]
https://www1.ietf.org/mailman/listinfo/rohc