Thursday, November 12, 2009

NetFPGA: A Tool for Network Research and Education

Summary

This paper describes NetFPGA, a project that is designed to give students practical experience with networking concepts at the physical and link layer. Students can use NetFPGA to build real networking hardware and because of its low cost, can connect many together to build interesting networking systems.

Till now, there have been 2 versions of NetFPGA. Version 1 includes 3 FPGA's, one of which is the Control FPGA, preprogrammed to connect the Etehrnet controller to the other 2 User FPGA's. The students built a simple logic analyzer in order to be able to see the signals in a waveform viewer.

There were several limitations to Version 1:
  • Board format was awkward, requiring self-assembly
  • Too slow for research projects
  • No on-board CPU
  • Windows not a possible development platform
This led to Version 2 of the NetFPGA. Version 2 switched to the PCI format which was beneficial because most users were already familiar with this format and it had greater bandwidth. It also possible to use ModelSim on XP to develop.

Future work includes further testing to analyze configuration and hardware problems in addition to improving the logic analyzer.

RCP and Intrustion Detection at ICSI are 2 projects currently making use of NetFPGA.

Critique & Questions

This was a quick read and a good introduction to NetFPGAs.

Tuesday, November 10, 2009

Internet Indirection Infrastructure

Summary

This paper describes an overlay network called Internet Indirection Infrastructure (i3) that is designed to easily provide services like multicast, anycast and mobility. i3 adds a level of indirection on top of the current network, separating the act of sending and receiving from each other. Rather than sending to one or more IP address, a sender will send to an logical identifier. Receivers will indicate which identifiers they are interested in receiving by way of triggers.

i3 was designed to be versatile, allowing users to create services like mobility, anycast and service composition on it. It also decentralized the responsibility for creating efficient trees by delegating that task to the end-hosts.

i3 uses a rendezvous-based communication. Each packet is represented by a (id, data) pair where id is an m-bit identifier and data is the IP packet payload. Receivers send out triggers of the form (id, addr) which states that all packets with an identifier id should be sent to addr. When a receiver would like to receive data, it can put out a trigger in the network. And, then when a packet with that id arrives, it will get sent to the receiver.

The authors implemented and evaluated i3 using the Chord lookup system. Initial evaluations suggest that i3 is highly flexible and can support many sophisticated applications.

Critique & Questions

Interesting paper. The rendezvous-style communication they used is fairly straightforward. Although from a practical implementation standpoint, there do seem to be many challenges to work through before that can take place. I liked that they acknowledged if/how i3 could be implemented for real.

A Policy-aware Switching Layer for Data Centers

Summary

This paper proposes PLayer, a policy aware layer-2 for data centers. PLayer is made up of inter-connected pswitches, policy-aware switches. Middleboxes can then be plugged into the pswitches, moving them off the network path. The pswitches are responsible for deciding which middleboxes each packet needs to go through and forwards the packet accordingly.

The main principles of PLayer are:
1) separating policy from reachability - middleboxes traversed are determined explicitly by a policy and not implicitly for network path selection mechanisms.
2) taking middleboxes off the physical network path - middleboxes are removed from choke points

PLayer aims to provide the following properties:
1) correctness
2) flexibility
3) efficiency

When forwarding packets, the PLayer uses centralized policy and middlebox controllers to setup and maintain the rule tables at the pswitches.

Critique & Questions

I thought this was a very well written and well structured paper. They did a good job at explaining the current problems in data centers. I also liked that they went into detail on how PLayer could be incorporated into the current infrastructure with minimal changes.

Wednesday, November 4, 2009

DNS Performance and the Effectiveness of Caching

Summary

This paper presents an analysis of traces of DNS and TCP traffic from MIT and KAIST. The paper explores the performance as perceived by the client and the effectiveness of caching.

Their data comes from 3 traces: 2 from MIT and one from KAIST. Their data includes outgoing DNS queries and incoming responses and outgoing TCP connection start and end packets. Most of the answered A lookups were followed by a TCP connection; those that weren't were excluded from the analysis. Also, any TCP connections that were not proceeded by DNS queries were excluded.

Client-Perceived Performance:

Latency was found to be adversly affected by the number of referrals that take place in a DNS query. 70% of the referrals were found to have cache hits for an NS record in the local DNS cache, showing that caching NS records are really beneficial as they reduce the load on the root servers.

They found that there was a large number unanswered lookups. They break unanswered lookups into 3 categories: zero referrals, non-zero referrals, and loops. They suggest that the large number of unanswered queries is due to the persistent retransmission strategy used by name servers and the referral loops that exist between name servers. They found that over 99.9% of answered queries were done in at most 2 retransmissions while over 90% required no retransmissions. Therefore, they conclude that the DNS name servers are too persistent in their retry strategy.

10-42% of lookups result in a negative answer. The largest cause are inverse lookups for IP addresses with no inverse mappings. They also found that negative caching may not be so effective because it has a heavy tailed distribution. 15-27% of lookups to root name servers resulted in negative responses, most probably caused by incorrectly implemented or configured resolvers.

Effectiveness of Caching:
- How useful is it share DNS caching among several client machines?
- What is the impact of the value of TTL on caching effectiveness?

Previous work shows that web object popularity follows a Zipf-like distribution. NS records were found to have much higher TTLs than A records, resulting in many fewer DNS requests to the root or gTLD servers. If the NS records weren't cached, the load would on the root or gTLD servers would have increased by a factor of 5, making NS record caching critical to DNS scalability.

They found that more popular domain names have shorter TTLs, supporting the idea that DNS-based load-balancing is useful only for popular sites.

They determine that sharing cache across many clients would not be very helpful. Sites common across the clients are the most popular ones, resulting in some performance gain there. However, most of the sites accessed are usually only accessed by one client. Even if a site is accessed multiple times, it is usually from the same client accessing it successively, and the client's local cache would be adequate for that.

They find that increasing TTL values increases hit rates, but is only noticeable for TTL values less than 1000 seconds. This is because most cache hits are due to multiple successive accesses of the same server by the same client. This suggests that low TTL values on A records wouldn't harm performance much.

Criticism & Questions

Another interesting paper. I think it did a good job at evaluating many of the features that were explained in the first paper. Their traces seemed like a good representation of the real-world environment. Most of their conclusions were logical based on the data they presented.

Most of the graphs were helpful in understanding their data, but some were really hard to make out. One thing that was especially confusing was that Table II came before Table I.

Development of the Domain Name System

Summary

This paper presents the original design, implementation, surprises, successes and shortcomings of the Domain Name System.

Before DNS, the HOSTS.TXT system was used to lookup the mapping from domain names to IP addresses. This system was essentially a single file, centrally located at the SRI Network Information Center and distributed to all hosts. As the network was growing larger and the number of hosts change from number of organizations to number of workstations, this was not a feasible solution. Existing systems at the time were IEN116 and XEROX. Neither fit their requirements and so they set out to design a new system.

The specification for DNS was that it should be a hierarchical name space with typed data at the nodes. Following are some of the requirements/assumptions for the DNS:
  • it should provide at least all the info in the HOSTS.TXT file
  • database should be maintable in a distributed manner
  • there should no obvious size limits for names, name components, data associated with a name, etc.
  • should interoperate across the DARPA internet and other environments
  • provide tolerable performance
DNS has 2 major active components: name servers and resolvers. Name servers store information and answer queries. Resolvers interface with the client programs and are responsible for finding the name server that has the information that the client wants.

The name space is a vairable-depth tree where each node has an associated label. There is not standard printing rule for the name format and it decouples the structre of the tree from any semantics.

There are 2 mechanisms for transferring data from source to destination: zones and caching. A zone includes a contiguous section of the tree, usually controlled by an organization and is responble for maintaining the zone's data and provide redudancy for the zone. DNS resolvers cache responses for the TTL specified by the zone.

The basic algorithm used by the DNS resolver is to search "downward" from domains that it can access already.

While building this system, they came across the following surprises:
  • refinements of semantics
  • performance of the network was much worse than the original design had expected, but lookups that required no network access did really well.
  • the need for negative caching
Some successes of the DNS system:
  • variable depth hierarchy
  • organizational structure of names
  • datagram access
  • additional section processing: responding server can anticipate next query and include that information in the response
  • caching
  • mail address cooperating
Some shortcomings of the DNS system:
  • type and class growth
  • easy upgrade of applications: hard to convert existing apps to use DNS
  • distribution of control vs. distribution of expertise/responsibility

Critique & Questions

Very interesting paper to read. It was nice to see the thought process around DNS. It is interesting to note that this paper deems caching as a success of DNS while the other paper we read shows that caching of A records is not very effective. This can probably be attributed to all the changes in the internet in the past 20 years. I wonder if the distribution of domain names when this paper was written (1988) would be Zipf-like, since there would presumably be fewer domain names. It's also important to note the lack of any authenticity and integrity checking of the data, which poses a security concern, something that was never considered in the original design.

Tuesday, November 3, 2009

Chord: A Scalable Peer-to-peer Lookup Service for Internet Applications

Summary

This paper describes, Chord, a lookup protocol for peer-to-peer applications. Chord uses DHT with consistent hashing, which provides load balancing and low overhead when a node joins or leaves the network. Chord is also scalable because in a N-node network, every node is only required to know about O(log N) nodes and requires O(log^2 N) messages when doing a lookup.

In the Chord protocol, every node and key is given an identifier using a base hash function. These identifiers determine which keys should reside on which node. After arranging all the nodes in order by their identifier in a clock-wise circle, a key is assigned to the first node whose identifier is equal to or follows the key's identifier. This is called the key's successor. Every node is also aware of its successor node.

When a node joins or leaves the network, only O(1/N) fraction of the keys need to moved to a new location. When a node n joins the network, it will be assigned some of the keys previously assigned to n's successor. And, when a node n leaves the network, its keys will be reassigned to its successor.

The basic idea of the algorithm, given that each node is only aware of its successor, is that when a node cannot resolve a lookup query itself, it will pass the query to its successor, which will then pass it to its successor until a node can resolve the lookup query. This will ensure correctness but will be inefficient. To improve its performance, each node can maintain additional routing information, allowing the node to pass each lookup query further than its successor and closer to the destination.

The authors simulated and implemented the Chord protocol, both of which confirmed that the latency grows with the number of nodes in the network.

Criticism & Questions

I enjoyed reading this paper. I think they did a good job of first explaining the overview of the algorithm and then going into details.

I did have one question about the algorithm. They explain that successor(k) is responsible for key k and what happens to keys when a node enters or leaves the network. However, I'm unsure of how the key-value entries are initially entered into each node's lookup table. Maybe the keys are assigned manually to whatever nodes exist when the application is set up?

Monday, November 2, 2009

Looking Up Data in P2P Systems

Summary

This paper explores peer to peer systems and looks at the Lookup Problem. The Lookup Problem can be stated as how to find a data item X given that it can be stored on a dynamic set of nodes.

There are 2 broad categories for solutions to this problem. The first are structured solutions. This includes maintaining a central database with filename-location mappings and a DNS-style hierarchical approach. Both of these have resilience problems since they store the data in a few critical nodes. The second category is symmetric schemes, in which every node is equally important to every other node. This category includes continually broadcasting to neighbors until a node has it in its database, which doesn't scale very well and using "superpeers" in a hierarchical structure, which again has resilience problems.

Most of the latest P2P lookup algorithms combine both of these categories to get structured symmetric algorithms which provide guarantees as well as resilience. All of these algorithms use a DHT. The general idea of the algorithm is that the lookup query is forwarded node to node, each time getting "closer" to the destination. "Closeness" can be measured in several ways: numeric differences between IDs, number of common prefix bits, bitwise XOR of the IDs.

Chord uses a skiplist-like routing, Pastry, Tapestry and Kademlia use tree-like routing and CAN uses d-dimensional routing. The authors conclude the paper with the following open questions: distance function, operation costs, fault tolerance and concurrent changes, proximity routing, malicious nodes, and indexing and keyword search.

Criticisms & Questions

I liked this paper. I think it did a good job at explaining the different lookup algorithms and the benefits and tradeoffs of each.

One interesting point they made about malicious nodes was that the worst a malicious node could do is "convincingly deny that data exists". This essentially becomes a DOS attack. Even if it is the worst case, isn't that still a cause for worry?