Check out the new USENIX Web site. next up previous
Next: Future work Up: Results Previous: Measurements


Code size

The code was compiled for the 32-bit Intel x86 and the 8-bit Atmel AVR platforms using gcc [28] versions 2.95.3 and 3.3 respectively, with code size optimization turned on. The resulting size of the compiled code can be seen in Tables 2 to 5. Even though both implementations support ARP and SLIP and lwIP includes UDP, only the protocols discussed in this paper are presented. Because the protocol implementations in uIP are tightly coupled, the individual sizes of the implementations are not reported.


Table 2: Code size for uIP (x86)
Function Code size (bytes)
Checksumming 464
IP, ICMP and TCP 4724
Total 5188


Table 3: Code size for uIP (AVR)
Function Code size (bytes)
Checksumming 712
IP, ICMP and TCP 4452
Total 5164


Table 4: Code size for lwIP (x86)
Function Code size (bytes)
Memory management 2512
Checksumming 504
Network interfaces 364
IP 1624
ICMP 392
TCP 9192
Total 14588


Table 5: Code size for lwIP (AVR)
Function Code size (bytes)
Memory management 3142
Checksumming 1116
Network interfaces 458
IP 2216
ICMP 594
TCP 14230
Total 21756

There are several reasons for the dramatic difference in code size between lwIP and uIP. In order to support the more complex and configurable TCP implementation, lwIP has significantly more complex buffer and memory management than uIP. Since lwIP can handle packets that span several buffers, the checksum calculation functions in lwIP are more complex than those in uIP. The support for dynamically changing network interfaces in lwIP also contributes to the size increase of the IP layer because the IP layer has to manage multiple local IP addresses. The IP layer in lwIP is further made larger by the fact that lwIP has support for UDP, which requires that the IP layer is able handle broadcast and multicast packets. Likewise, the ICMP implementation in lwIP has support for UDP error messages which have not been implemented in uIP.

The TCP implementation is lwIP is nearly twice as large as the full IP, ICMP and TCP implementation in uIP. The main reason for this is that lwIP implements the sliding window mechanism which requires a large amount of buffer and queue management functionality that is not required in uIP.

The different memory and buffer management schemes used by lwIP and uIP have implications on code size, mainly in 8-bit systems. Because uIP uses a global buffer for all incoming packets, the absolute memory addresses of the protocol header fields are known at compile time. Using this information, the compiler is able to generate code that uses absolute addressing, which on many 8-bit processors requires less code than indirect addressing.

Is it interesting to note that the size of the compiled lwIP code is larger on the AVR than on the x86, while the uIP code is of about the same size on the two platforms. The main reason for this is that lwIP uses 32-bit arithmetic to a much larger degree than uIP and each 32-bit operation is compiled into a large number of machine code instructions.


next up previous
Next: Future work Up: Results Previous: Measurements
Adam Dunkels 2003-03-03