W3C home > Mailing lists > Public > ietf-http-wg-old@w3.org > January to April 2000

Re: On pipelining

From: Fred Bohle <fbohle@neonsys.com>
Date: Fri, 21 Jan 2000 09:48:42 -0600
To: "Daniel Hellerstein" <DANIELH@mailbox.econ.ag.gov>
cc: http-wg@cuckoo.hpl.hp.com
Message-ID: <8625686D.00571D35.00@internet1.neonsys.com>

Fred Bohle@NEON
01/21/2000 09:48 AM


     I would suggest that the multi-threading be done at the connection
not at the request level.  That way you can be sure the requests are
handled in their
proper order.  Multi-threading at the request level would require some
other mechanism
to be sure that they are executed in the same order, defeating the purpose
of multi-
threading.  At a minimum, you must return the responses in the same order
that you
received them.  Again multi-threading the requests would require a
mechanism to
ensure this order, minimizing the benefits of such multi-threading.

     Consider three requests that:
1. display a database item.
2. update that database item.
3. display the same database item.

The intent here is to show the before and after views of the database item.
In a
multi-threaded request server, if the requests execute in 1,3,2 order, or
2,1,3 order,
the before/after sense of the display is lost.  Note that this is true even
if you force
the order of responses to be reshuffled as 1,2,3.

     So, I don't see how you can make it work if you multi-thread the

Fred Bohle

"Daniel Hellerstein" <DANIELH@mailbox.econ.ag.gov> on 01/21/2000 09:35:53

To:   http-wg@cuckoo.hpl.hp.com
cc:    (bcc: Fred Bohle/Dev/Neon)

Subject:  On pipelining

I'm redoing the persistent-connection/pipelining support in my web
server, and
the question came up of how to resolve pipelined requests. By resolve,
I mean
the act of the server using the request line (and headers, etc) to
determine which file to read, which script to run, etc ... the end
result being the creation of  a response to  send to the client.

Basically,  in the following scenario (from mike sabin)..

>  Request1
>  Request2
 > Request3
>         Response1
>           Response2
 >         Response3
>(although, clearly, if there are many requests we might expect
>the request stream to partially overlap the response stream).

would "resolution of request2" await the completion of transmission
of response1? Or can these  3 requests be resolved simultaneously
(say, using
seperate threads); with first response1 sent, then 2, then 3.
That is, could a multi-threaded server create response2,  wait for
succesful transmission of  response1 (over the persistent connection),
and then transmit response2 (over this
same persistent connection)?

This is a problem if the resolution of request2 can depend on the
resolution of
request 1 (for example, when request1 causes some client-specific
state variable, that is  used in request2, to change)

The definition of idempotency (rfc2616  9.1.2)  suggests NO -- since
identical sequences should return the same result, which would
situations where the oddities of server load may dictate the  speed
with which
simultaneously resolved requests are processed.

Any strong opinions?

Daniel Hellerstein
Received on Friday, 21 January 2000 15:53:41 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 14:40:24 UTC