RFC 6675

A Conservative Loss Recovery Algorithm Based on Selective Acknowledgment (SACK) for TCP

📅 published August 2012, from ietf

RFC 6675: A Conservative Loss Recovery Algorithm Based on Selective Acknowledgment (SACK) for TCP ✨

okay bestie, let's dive into RFC 6675 🎀 it's an IETF Standards Track doc, published August 2012 (ISSN 2070-1721), and it obsoletes RFC 3517 🦋 so 3517 is retired and this is the new version. no updates listed.

the authors are E. Blanton (Purdue University), M. Allman (ICSI), L. Wang (Juniper Networks), I. Jarvinen, and M. Kojo (University of Helsinki), plus Y. Nishida (WIDE Project). the squad is iconic 👑

Abstract

okay so the abstract says this doc is a conservative loss recovery algorithm for TCP that's built on the SACK TCP option 💖 it still vibes with the congestion control spec (RFC 5681), but it lets senders recover better when a bunch of segments get lost from one flight of data. and it obsoletes RFC 3517 and explains what changed 🔥

Status of This Memo

this is an Internet Standards Track document 🌸 it's a product of the IETF, it represents the community's consensus, got public review, and was approved by the IESG. if you want the deets on Internet Standards, check Section 2 of RFC 5741 ✨

for the current status, errata, and how to send feedback, the page is http://www.rfc-editor.org/info/rfc6675 💅

Copyright (c) 2012 IETF Trust and the persons identified as the document authors. All rights reserved. 🌈

this doc is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) as of the publication date. read those carefully, bestie, because they explain your rights and restrictions 🫶

if you pull Code Components out of this doc, they have to include Simplified BSD License text (as described in Section 4.e of the Trust Legal Provisions), and they come with no warranty, per the Simplified BSD License 😭

1. Introduction ✨

okay so this section basically repeats the vibe: a conservative loss recovery algorithm for TCP that uses the SACK TCP option [RFC2018] 💜 SACK is getting steadily deployed on the Internet ([All00]), but there's evidence hosts aren't actually using the SACK info when they make retransmission and congestion control decisions ([PF01]) 🙈 so the goal here is to outline one straightforward way for TCP implementations to use SACK info and boost performance ⭐

[RFC5681] lets TCP ([RFC793]) use advanced loss recovery algorithms as long as they follow the spirit of TCP's congestion control algorithms ([RFC5681] [RFC2914]) 🦋 [RFC6582] covers one such advanced algorithm, called NewReno 🍓 this doc outlines a loss recovery algorithm that uses the SACK TCP option [RFC2018] to level up TCP's loss recovery 💅

the algorithm here is heavily based on the one in [FF96], and it's a conservative replacement for the fast recovery algorithm ([Jac90] [RFC5681]) 🔥 it's a straightforward SACK-based strategy that follows the guidelines in [RFC5681] and can safely be used in TCP implementations 🎀

implementers can use alternate SACK-based loss recovery methods in TCP as they see fit, as long as those alternates follow the guidelines in [RFC5681] 🌸 but heads up: the SACK-based decisions here (like which segments get sent at what time) are mostly decoupled from the congestion control algorithms, so you can treat them as separate issues if you want 🧚

this doc is a revision of [RFC3517] to handle a few situations that weren't explicitly covered there 💖 there's a summary of the changes from [RFC3517] in Section 9 ✨

2. Definitions

okay now the key words. the words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be read as described in BCP 14, RFC 2119 [RFC2119] 👑

you're expected to already know the definitions in [RFC5681] 💅 and you're assumed to be familiar with selective acknowledgments as specified in [RFC2018] 🫶

to explain the SACK-based loss recovery algorithm, we define six variables that a TCP sender stores 🧚

  • "HighACK" is the sequence number of the highest byte of data that has been cumulatively ACKed at a given point.
  • "HighData" is the highest sequence number transmitted at a given point.
  • "HighRxt" is the highest sequence number that has been retransmitted during the current loss recovery phase.
  • "RescueRxt" is the highest sequence number that has been optimistically retransmitted to stop the ACK clock from stalling when there's loss at the end of the window and no new data is available to send 😭
  • "Pipe" is a sender's estimate of the number of bytes outstanding in the network 🌈 it's used during recovery to limit the sending rate. the pipe variable lets TCP use fundamentally different congestion control than the algorithm in [RFC5681]. the congestion control algorithm that uses the pipe estimate is often called the "pipe algorithm" ✨
  • "DupAcks" is the number of duplicate acknowledgments received since the last cumulative acknowledgment.

now the "duplicate acknowledgment" definition for this spec: it's a segment that arrives carrying a SACK block that identifies previously unacknowledged and un-SACKed octets between HighACK and HighData 💜 an ACK that carries new SACK data counts as a duplicate acknowledgment under this definition, even if it also carries new data, changes the advertised window, or moves the cumulative acknowledgment point 🙈 that's different from the definition of duplicate acknowledgment in [RFC5681], so be careful, bestie ⚠️

we define a variable "DupThresh" that holds the number of duplicate acknowledgments required to trigger a retransmission 🍓 per [RFC5681], this threshold is 3 duplicate acknowledgments. but implementers should check any updates to [RFC5681] to figure out the current value for DupThresh (or the method for determining it) 🔥

last one: a range of sequence numbers [A,B] is said to "cover" sequence number S if A <= S <= B 🌸

3. Keeping Track of SACK Information

so for a TCP sender to run the algorithm in the next section, it must keep a data structure that stores incoming selective acknowledgment info on a per-connection basis 💖 that's usually called the "scoreboard" ✨ the specifics of the scoreboard are out of scope for this document, as long as the implementation can perform all the functions required by this spec 🦋

this doc talks about keeping account of (marking) individual octets of data transferred across a TCP connection 🎀 but a real-world scoreboard would probably prefer to manage this data as sequence number ranges 🧚 the algorithms here allow that, but they require the ability to mark arbitrary sequence number ranges as selectively acknowledged 💅

also, the algorithm here assumes a sender that is NOT keeping track of segment boundaries after transmitting a segment 🙈 a more refined and precise algorithm might exist for a sender that keeps that extra state, but that's left as future work 👑

4. Processing and Acting Upon SACK Information

this section describes a specific structure and control flow for implementing the TCP behavior described by this standard 💜 the behavior is what's standardized. this particular set of functions is the strongly recommended way to implement that behavior, though other approaches are feasible 🌈

the definition of Sender Maximum Segment Size (SMSS) used in this section comes from [RFC5681] ✨

for the algorithm in this document, the scoreboard SHOULD implement the following functions 🔥

Update ()

given the info in an ACK, each octet that's cumulatively ACKed or SACKed should be marked accordingly in the scoreboard data structure, and the total number of octets SACKed should be recorded 🎀

Note: SACK information is advisory, so SACKed data MUST NOT be removed from the TCP's retransmission buffer until the data is cumulatively acknowledged [RFC2018] ⚠️

IsLost (SeqNum)

this routine returns whether the given sequence number is considered lost 🌸 it returns true when either DupThresh discontiguous SACKed sequences have arrived above 'SeqNum', or more than (DupThresh - 1) * SMSS bytes with sequence numbers greater than 'SeqNum' have been SACKed. otherwise it returns false 💖

SetPipe ()

this routine walks the sequence space from HighACK to HighData and MUST set the "pipe" variable to an estimate of the number of octets currently in transit between the TCP sender and the TCP receiver 🦋 after setting pipe to zero, these steps happen for each octet 'S1' in the sequence space between HighACK and HighData that hasn't been SACKed 🧚

  • (a) If IsLost (S1) returns false:

pipe gets incremented by 1 octet 💅

the effect here: pipe goes up for packets that aren't SACKed and haven't been determined lost (aka the ones still assumed to be in the network) ✨

  • (b) If S1 <= HighRxt:

pipe gets incremented by 1 octet 🌈

the effect here: pipe goes up for the retransmission of the octet 🔥

note that octets retransmitted without being considered lost get counted twice by the above mechanism 😭

NextSeg ()

this routine uses the scoreboard maintained by the Update() function to figure out what to transmit, based on the SACK info that arrived from the data receiver (and so got marked in the scoreboard) 🫶 NextSeg () MUST return the sequence number range of the next segment to transmit, following these rules 👑

  • (1) If there's a smallest unSACKed sequence number 'S2' that meets all three of the following criteria for determining loss, the sequence range of one segment of up to SMSS octets starting with S2 MUST be returned 💜
    • (1.a) S2 is greater than HighRxt.
    • (1.b) S2 is less than the highest octet covered by any received SACK. 🙈

(1.c) IsLost (S2) returns true. 💅

(2) Okay, so if there's no sequence number S2 from rule (1) but there IS unsent data waiting and the receiver's advertised window has room, then one chunk of up to SMSS octets of previously unsent data, starting at HighData+1, MUST be returned. Fresh data, bestie 🌸

(3) If rules (1) and (2) both flop, but there's an unSACKed sequence number S3 that passes the loss-detection checks in steps (1.a) and (1.b) above (and we're specifically skipping step (1.c) here), then one segment of up to SMSS octets starting with S3 SHOULD be returned. 🦋

(4) If (1), (2), and (3) all fail, but there's still outstanding unSACKed data, we get a single "rescue" retransmission per entry into loss recovery 🚑. If HighACK is greater than RescueRxt (or RescueRxt is undefined), then one segment of up to SMSS octets that MUST include the highest outstanding unSACKed sequence number SHOULD be returned, and RescueRxt gets set to RecoveryPoint. HighRxt MUST NOT be updated. 🙈

Note that rules (3) and (4) are basically the retransmission "last resort" 🥺. They allow retransmission of sequence numbers even when the sender is less certain a segment was lost than under rule (1). Retransmitting via rules (3) and (4) helps sustain the TCP's ACK clock, so it can potentially help avoid retransmission timeouts. However, when the sender does this, it has two copies of the same data considered to be in the network (and also in the pipe estimate, in the case of (3)). When an ACK or SACK arrives covering this retransmitted segment, the sender can't be sure exactly how much data left the network (one of the two transmissions of the packet, or both transmissions of the packet). Therefore, the sender may underestimate pipe by considering both segments to have left the network when it is possible that only one of the two has. It's giving "risky but worth it" energy ✨

(5) If the conditions for each of (1), (2), (3), and (4) are not met, then NextSeg () MUST indicate failure, and no segment is returned. 💀

Note: The SACK-based loss recovery algorithm outlined in this document requires more computational resources than previous TCP loss recovery strategies. However, we believe the scoreboard data structure can be implemented in a reasonably efficient manner (both in terms of computation complexity and memory usage) in most TCP implementations. Efficient AND lowkey iconic 👑

5. Algorithm Details ✨

Upon the receipt of any ACK containing SACK information, the scoreboard MUST be updated via the Update () routine. 📝

If the incoming ACK is a cumulative acknowledgment, the TCP MUST reset DupAcks to zero. 🧹

If the incoming ACK is a duplicate acknowledgment per the definition in Section 2 (regardless of its status as a cumulative acknowledgment), and the TCP is not currently in loss recovery, the TCP MUST increase DupAcks by one and take the following steps: 👀

(1) If DupAcks >= DupThresh, go to step (4).

Note: This check covers the case when a TCP receives SACK information for multiple segments smaller than SMSS, which can potentially prevent IsLost() (next step) from declaring a segment as lost. Little segments being sneaky 🙄

(2) If DupAcks < DupThresh but IsLost (HighACK + 1) returns true -- indicating at least three segments have arrived above the current cumulative acknowledgment point, which is taken to indicate loss -- go to step (4). 🚨

(3) The TCP MAY transmit previously unsent data segments as per Limited Transmit [RFC5681], except that the number of octets which may be sent is governed by pipe and cwnd as follows:

(3.1) Set HighRxt to HighACK.

(3.2) Run SetPipe ().

(3.3) If (cwnd - pipe) >= 1 SMSS, there exists previously unsent data, and the receiver's advertised window allows, transmit up to 1 SMSS of data starting with the octet HighData+1 and update HighData to reflect this transmission, then return to (3.2). 🔁

(3.4) Terminate processing of this ACK. 🛑

(4) Invoke fast retransmit and enter loss recovery as follows:

(4.1) RecoveryPoint = HighData

When the TCP sender receives a cumulative ACK for this data octet, the loss recovery phase is terminated. 🎉

(4.2) ssthresh = cwnd = (FlightSize / 2)

The congestion window (cwnd) and slow start threshold (ssthresh) are reduced to half of FlightSize per [RFC5681]. Additionally, note that [RFC5681] requires that any segments sent as part of the Limited Transmit mechanism not be counted in FlightSize for the purpose of the above equation. Math check passed 🧮

(4.3) Retransmit the first data segment presumed dropped -- the segment starting with sequence number HighACK + 1. To prevent repeated retransmission of the same data or a premature rescue retransmission, set both HighRxt and RescueRxt to the highest sequence number in the retransmitted segment. 🩹

(4.4) Run SetPipe ()

Set a "pipe" variable to the number of outstanding octets currently "in the pipe"; this is the data which has been sent by the TCP sender but for which no cumulative or selective acknowledgment has been received and the data has not been determined to have been dropped in the network. It is assumed that the data is still traversing the network path. 🛣️

(4.5) In order to take advantage of potential additional available cwnd, proceed to step (C) below. 🏃‍♀️

Once a TCP is in the loss recovery phase, the following procedure MUST be used for each arriving ACK: 📋

(A) An incoming cumulative ACK for a sequence number greater than RecoveryPoint signals the end of loss recovery, and the loss recovery phase MUST be terminated. Any information contained in the scoreboard for sequence numbers greater than the new value of HighACK SHOULD NOT be cleared when leaving the loss recovery phase. Recovery ARC complete 🏁

(B) Upon receipt of an ACK that does not cover RecoveryPoint, the following actions MUST be taken:

(B.1) Use Update () to record the new SACK information conveyed by the incoming ACK.

(B.2) Use SetPipe () to re-calculate the number of octets still in the network.

(C) If cwnd - pipe >= 1 SMSS, the sender SHOULD transmit one or more segments as follows:

(C.1) The scoreboard MUST be queried via NextSeg () for the sequence number range of the next segment to transmit (if any), and the given segment sent. If NextSeg () returns failure (no data to send), return without sending anything (i.e., terminate steps C.1 -- C.5). 🫶

(C.2) If any of the data octets sent in (C.1) are below HighData, HighRxt MUST be set to the highest sequence number of the retransmitted segment unless NextSeg () rule (4) was invoked for this retransmission.

(C.3) If any of the data octets sent in (C.1) are above HighData, HighData must be updated to reflect the transmission of previously unsent data.

(C.4) The estimate of the amount of data outstanding in the network must be updated by incrementing pipe by the number of octets transmitted in (C.1).

(C.5) If cwnd - pipe >= 1 SMSS, return to (C.1). 🔄

Note that steps (A) and (C) can potentially send a burst of back-to-back segments into the network if the incoming cumulative acknowledgment is for more than SMSS octets of data, or if incoming SACK blocks indicate that more than SMSS octets of data have been lost in the second half of the window. Burst alert 🚨💜

5.1. Retransmission Timeouts 💖

In order to avoid memory deadlocks, the TCP receiver is allowed to discard data that has already been selectively acknowledged. As a result, [RFC2018] suggests that a TCP sender SHOULD expunge the SACK information gathered from a receiver upon a retransmission timeout (RTO) "since the timeout might indicate that the data receiver has reneged." Additionally, a TCP sender MUST "ignore prior SACK information in determining which data to retransmit." However, since the publication of [RFC2018], this has come to be viewed by some as too strong. It has been suggested that, as long as robust tests for reneging are present, an implementation can retain and use SACK information across a timeout event [Errata1610]. While this document does not change the specification in [RFC2018], we note that implementers should consult any updates to [RFC2018] on this subject. Further, a SACK TCP sender SHOULD utilize all SACK information made available during the loss recovery following an RTO. Plot twist energy 🎭

If an RTO occurs during loss recovery as specified in this document, RecoveryPoint MUST be set to HighData. Further, the new value of RecoveryPoint MUST be preserved and the loss recovery algorithm outlined in this document MUST be terminated. In addition, a new recovery phase (as described in Section 5) MUST NOT be initiated until HighACK is greater than or equal to the new value of RecoveryPoint. 🚫

As described in Sections 4 and 5, Update () SHOULD continue to be used appropriately upon receipt of ACKs. This will allow the recovery period after an RTO to benefit from all available information provided by the receiver, even if SACK information was expunged due to the RTO. Memory of the receiver is iconic 🧠

If there are segments missing from the receiver's buffer following processing of the retransmitted segment, the corresponding ACK will contain SACK information. In this case, a TCP sender SHOULD use this SACK information when determining what data should be sent in each segment following an RTO. The exact algorithm for this selection is not specified in this document (specifically NextSeg () is inappropriate during loss recovery after an RTO). A relatively straightforward approach to "filling in" the sequence space reported as missing should be a reasonable approach. 🧩

6. Managing the RTO Timer 🎀

The standard TCP RTO estimator is defined in [RFC6298]. Due to the fact that the SACK algorithm in this document can have an impact on the behavior of the estimator, implementers may wish to consider how the timer is managed. [RFC6298] calls for the RTO timer to be re-armed each time an ACK arrives that advances the cumulative ACK point. Because the algorithm presented in this document can keep the ACK clock going through a fairly significant loss event (comparatively longer than the algorithm described in [RFC5681]), on some networks the loss event could last longer than the RTO. In this case the RTO timer would expire prematurely and a segment that need not be retransmitted would be resent. Oops, not it 😭

Therefore, we give implementers the latitude to use the standard [RFC6298]-style RTO management or, optionally, a more careful variant that re-arms the RTO timer on each retransmission that is sent during recovery MAY be used. This provides a more conservative timer than specified in [RFC6298], and so may not always be an attractive alternative. However, in some cases it may prevent needless retransmissions, go-back-N transmission, and further reduction of the congestion window. Choose your timer wisely, bestie 💅🌈

7. Research ✨

okay so the algorithm in this doc got studied in [FF96] and it lowkey slaps 💅. That paper shows it cuts transfer time compared to standard TCP Reno [RFC5681] when a bunch of segments get dropped out of one window of data. And the more drops there are, the more it helps 📈. [AHKO97] also found that this algorithm can seriously boost throughput for connections going over satellite channels 🛰️✨

8. Security Considerations 🔐

bestie, this part is serious, so read it carefully 🫶 The algorithm in this paper shares security considerations with [RFC5681]. The big difference is that an algorithm based on SACKs is way more robust against attackers who forge duplicate ACKs to trick the TCP sender into lowering cwnd. With SACKs, the TCP sender gets an extra check on whether a particular ACK is legit. It's not fool-proof, but SACK does give you some protection here 🛡️

Also, [CPNI309] sketches a variant of a blind attack [RFC5961]. In it, an attacker spoofs out-of-window data to a TCP endpoint, which makes that endpoint send a duplicate cumulative ACK to the legit peer, as described in [RFC793]. Adding a SACK-based requirement before loss recovery gets triggered works really well against this 💖 The duplicate ACKs caused by out-of-window segments won't carry any SACK info showing that previously un-SACKed in-window data was received, so the attack doesn't get to start loss recovery 🙅‍♀️

9. Changes Relative to RFC 3517 🦋

so what's new compared to [RFC3517]? Lots of cute stuff 🎀

The state variable "DupAcks" got added to the list of variables this algorithm keeps track of, and its usage is spelled out now 📝

The function IsLost () was changed. Now more than (DupThresh - 1) * SMSS octets have to be SACKed above a given sequence number before it counts as lost. The old minimum in [RFC3517] was (DupThresh * SMSS). This still keeps the rule that at least three segments after the sequence number in question have been SACKed, and it also improves detection when the sender has outstanding segments that are smaller than SMSS 🔍✨

The definition of a "duplicate acknowledgment" now uses the SACK info to detect loss. Here's the deal: duplicate cumulative acknowledgments can come from loss or from reordering in the network. To tell those apart, TCP's fast retransmit algorithm [RFC5681] waits until three duplicate ACKs show up before it triggers loss recovery. That idea became the basis for the algorithm in [RFC3517]. But with SACK info, there's no need to blindly rely on the cumulative acknowledgment field 🙌 The SACK blocks tell us that three segments above a gap in the sequence space have arrived at the receiver, and we can use that to trigger loss recovery. [RFC3517] used this idea during loss recovery already. What's different here is that this document also uses it to enter a loss recovery phase 🚀

The state variable "RescueRxt" got added to the list of variables the algorithm maintains, and its usage is specified too. This variable allows one extra retransmission per entry into loss recovery. The purpose is to keep the ACK clock going in certain situations involving loss at the end of the window 🎢 This mechanism allows no more than one segment of no larger than 1 SMSS to be optimistically retransmitted per loss recovery, so it's a tiny but important lil safety valve 💜

Rule (3) of NextSeg() changed from MAY to SHOULD. That shift reflects what the authors and working group think: if an implementor doesn't have a compelling reason to do otherwise, the rule should be left in rather than taken out 🌸

10. Acknowledgments 🫶

the authors want to thank Sally Floyd for encouraging [RFC3517] and commenting on early drafts 💐 The algorithm in this document is loosely based on an algorithm outlined by Kevin Fall and Sally Floyd in [FF96]. The authors take responsibility for any mistakes in the text above, not them 😇

Kevin Fall co-authored [RFC3517], and his crucial input to that document also helped this follow-on work 👑

Thank you to Murali Bashyam, Ken Calvert, Tom Henderson, Reiner Ludwig, Jamshid Mahdavi, Matt Mathis, Shawn Ostermann, Vern Paxson, and Venkat Venkatsubra for giving valuable feedback on earlier versions of this document 💖

Matt Mathis and Jamshid Mahdavi also get a huge thank-you for implementing the scoreboard in ns, which guided the team's thinking about keeping track of SACK state 🧚

The first author would like to thank Ohio University and the Ohio University Internetworking Research Group for supporting most of his work on RFC 3517, which this document is derived from 🎓🍓

11. References 📚

11.1. Normative References

  • [RFC793] Postel, J., "Transmission Control Protocol", STD 7, RFC 793, September 1981.
  • [RFC2018] Mathis, M., Mahdavi, J., Floyd, S., and A. Romanow, "TCP Selective Acknowledgment Options", RFC 2018, October 1996.
  • [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
  • [RFC5681] Allman, M., Paxson, V., and E. Blanton, "TCP Congestion Control", RFC 5681, September 2009.

11.2. Informative References

  • [AHKO97] Mark Allman, Chris Hayes, Hans Kruse, Shawn Ostermann, "TCP Performance Over Satellite Links", Proceedings of the Fifth International Conference on Telecommunications Systems, Nashville, TN, March, 1997.
  • [All00] Mark Allman, "A Web Server's View of the Transport Layer", ACM Computer Communication Review, 30(5), October 2000.
  • [CPNI309] Fernando Gont, "Security Assessment of the Transmission Control Protocol (TCP)", CPNI Technical Note 3/2009, http://www.gont.com.ar/papers/tn-03-09-security-assessment-TCP.pdf, February 2009.
  • [Errata1610] RFC Errata, Errata ID 1610, RFC 2018, http://www.rfc-editor.org.
  • [FF96] Kevin Fall and Sally Floyd, "Simulation-based Comparisons of Tahoe, Reno and SACK TCP", Computer Communication Review, July 1996.
  • [Jac90] Van Jacobson, "Modified TCP Congestion Avoidance Algorithm", Technical Report, LBL, April 1990.
  • [PF01] Jitendra Padhye, Sally Floyd "Identifying the TCP Behavior of Web Servers", ACM SIGCOMM, August 2001.
  • [RFC6582] Henderson, T., Floyd, S., Gurtov, A., and Y. Nishida, "The NewReno Modification to TCP's Fast Recovery Algorithm", RFC 6582, April 2012.
  • [RFC2914] Floyd, S., "Congestion Control Principles", BCP 41, RFC 2914, September 2000.
  • [RFC6298] Paxson, V., Allman, M., Chu, J., and M. Sargent, "Computing TCP's Retransmission Timer", RFC 6298, June 2011.
  • [RFC3517] Blanton, E., Allman, M., Fall, K., and L. Wang, "A Conservative Selective Acknowledgment (SACK)-based Loss Recovery Algorithm for TCP", RFC 3517, April 2003.
  • [RFC5961] Ramaiah, A., Stewart, R., and M. Dalal, "Improving TCP's Robustness to Blind In-Window Attacks", RFC 5961, August 2010.

Authors' Addresses 🎀

Ethan Blanton
Purdue University Computer Sciences
305 N. University St.
West Lafayette, IN 47907
United States
EMail: elb@psg.com

Mark Allman
International Computer Science Institute
1947 Center St. Suite 600
Berkeley, CA 94704
United States
EMail: mallman@icir.org
http://www.icir.org/mallman

Lili Wang
Juniper Networks
10 Technology Park Drive
Westford, MA 01886
United States
EMail: liliw@juniper.net

Ilpo Jarvinen
University of Helsinki
P.O. Box 68
FI-00014 UNIVERSITY OF HELSINKI
Finland
EMail: ilpo.jarvinen@helsinki.fi

Markku Kojo
University of Helsinki
P.O. Box 68
FI-00014 UNIVERSITY OF HELSINKI
Finland
EMail: kojo@cs.helsinki.fi

Yoshifumi Nishida
WIDE Project
Endo 5322
Fujisawa, Kanagawa 252-8520
Japan
EMail: nishida@wide.ad.jp
📦 where this page comes from