Issue 1677:  Chunked GIOP marshalling for variable-length types (interop)
Source:  (, )
Nature:  Uncategorized Issue
Severity: 
Summary: Summary: Following the discussion of valuetype chunking in the OBV group, I"ve
 been thinking that the arguments advanced for it really apply to all
 the other variable-length types in CORBA (sequences and strings) as
 well as to OBV value types, and wonder if we might try a small change
 to the marshalling rules.
 
 Currently, we marshal a string (say) by sending the length of the
 string followed by the bytes of the string.  If we don"t know the
 string"s length in advance, say because we are reading it from stdin
 or a subprocess, we need to buffer it in memory and send it as one big
 thing.  That"s inefficient.
 
 

Resolution: Close this previously deferred issue as too much for RTF.  Add to GIOP future version "wish list" do
Revised Text: 
Actions taken:
July 14, 1998: received issue
February 27, 2001: closed issue
Discussion: 

End of Annotations:=====
Return-Path: <janssen@parc.xerox.com>
Sender: Bill Janssen <janssen@parc.xerox.com>
From: Bill Janssen <janssen@parc.xerox.com>
To: issues@omg.org
Subject: chunked GIOP marshalling for variable-length types
Cc: interop@omg.org
Date: Mon, 13 Jul 1998 23:04:58 PDT

[ I think this is a joint interop/OBV issue. ]

Following the discussion of valuetype chunking in the OBV group, I've
been thinking that the arguments advanced for it really apply to all
the other variable-length types in CORBA (sequences and strings) as
well as to OBV value types, and wonder if we might try a small change
to the marshalling rules.

Currently, we marshal a string (say) by sending the length of the
string followed by the bytes of the string.  If we don't know the
string's length in advance, say because we are reading it from stdin
or a subprocess, we need to buffer it in memory and send it as one big
thing.  That's inefficient.

Suppose, though, in CDR we sent variable-length things as sequences of
chunks, using something like the ONC RPC record-marking protocol.
That is, instead of sending a string as a 32-bit length followed by
the bytes of the string, we send a 32 bit value which consists of a
1-bit flag and a 31-bit chunk length.  The flag is clear (0) if the
chunk is the last chunk of the string, set (1) if it is not the last
chunk of the string.  We can send an arbitrary number of these chunks.

Same for sequence types, except that each chunk-length gives the
number of elements of the sequence in the chunk, rather than the
number of bytes.

Note that this would apply to encapsulations, as well, since they
are sequences of octets.  Note also that this solves a different
problem than is addressed by GIOP message-chunking, at a different
level.

To exploit this from language mappings might require some small
changes, such as a pull-driven marshalling option for static stubs,
and a minor tweak to the DII streams interfaces.  But those could
come after we've tweaked CDR to accommodate them.  The current
mappings would continue to work in the current fashion.

Bill