How to integrate GNS3 and Mininet.

Before we dive into the configuration first lets review the components needed to build the lab.

1. GNS3 is a software suite that simulates complex networks, providing an intuitive graphical user interface to design and configure virtual networks.
2. Virtualbox is a virtualization software package for x86 and AMD64/Intel64-based computers from Oracle Corporation. It can be integrated into the GNS3 software suite.
3. MiniNet is an OpenFlow testing platform consisting of a realistic virtual network, running real kernel, switch and application code, with a single command prompt.

Virtualbox / Mininet 

Download Virtualbox HERE, and install (default settings are fine in most cases). Download Mininet HERE. After installing Virtualbox, and downloading Mininet. 

Now create the Mininet VM in Virtualbox. To do this select NEW button from the toolbar and go through the wizard to install the Mininet VM. At step one select the name and operating system. Type is Linux and Version is Ubuntu. Click NEXT through the memory size configuration. At the Hard drive selection option, select 'Use an existing virtual hard drive file' and add the mininet vmdk file. Now click CREATE.

The Mininet VM is created. Now we need to add extra network adapters to Virtualbox. To do this open the File -> Preferences... menu item, and open the NETWORK tab. Within the NETWORK tab, select the 'Host-only Adapter' tab and click 'Add host-only network' icon, until there are at least three 'VirtualBox Host-Only Adapter's', then click OK.

Now we need to configure the Mininet VM with the newly created virtual ethernet adapters. To do this open the SETTINGS button, and open the NETWORK tab. Select the 'Host-only Adapter', choose the first 'Virtual Host-Only Ethernet Adapter'. And open the Advanced settings of the adapter, and uncheck the 'Cable Connected' option. Add Adapter 2 and Adapter 3 in the same way. And click OK.

Virtualbox is now configured.

GNS3

In GNS3 click Edit -> Preferences... and open the VirtualBox tab. Select the 'VirtualBox Guest' sub tab. Now select the 'Mininet' VM from the 'VM List' drop down list. Set the 'Number of NICs' to 3, and check the 'Reserve first NIC for VirtualBox NAT to host OS', the 'Enable Console Support', and the 'Enable Console Server' checkboxes. Add an 'Identifier name', I choose Mininet, click SAVE button and then click OK button.

Now we are ready the to build our first lab.

The lab

For demonstration purposes the lab will consist of two routers connected to the Mininet VM. The Mininet VM will be started in the standard configuration: one Openflow switch, one controller, and two virtual hosts.

After which I manually attached both the interfaces eth1 and eth2, to the switch s1.

Both routers are configured with in the IP range 10.0.0.0/24. The .1 and .2 are used by the two virtual hosts.

The result of a ping from R1 to R2, from the perspective of R2.

R2#
*Mar  1 00:07:24.155: IP ARP: rcvd req src 10.0.0.3 c00d.2440.0000, dst 10.0.0.4 FastEthernet0/0
*Mar  1 00:07:24.155: IP ARP: sent rep src 10.0.0.4 c00e.2440.0000,
                 dst 10.0.0.3 c00d.2440.0000 FastEthernet0/0
*Mar  1 00:07:24.159: IP ARP: rcvd rep src 10.0.0.3 c00d.2440.0000, dst 10.0.0.3 FastEthernet0/0
R2#
*Mar  1 00:07:42.775: ICMP: echo reply sent, src 10.0.0.4, dst 10.0.0.3
*Mar  1 00:07:42.823: ICMP: echo reply sent, src 10.0.0.4, dst 10.0.0.3
*Mar  1 00:07:42.847: ICMP: echo reply sent, src 10.0.0.4, dst 10.0.0.3
*Mar  1 00:07:42.867: ICMP: echo reply sent, src 10.0.0.4, dst 10.0.0.3

*Mar  1 00:07:42.887: ICMP: echo reply sent, src 10.0.0.4, dst 10.0.0.3

Conclusion

Mininet provides a great tool to experiment with Software-defined networking (SDN), while providing an software switching platform within the GNS3 environment. Non of the routers available in the GNS3 (officially) support Openflow. Limiting the experimentation with Openflow to switching only.

References

• Mininet Walkthrough
• Virtualbox documentation
• GNS3 documentation
• Original Whitepaper proposing OpenFlow 

Browser Battle: the 5 most popular Android browsers benchmarked.

Normally I write about Cisco and network engineering related stuff. But today I decided, I'll do something different for a change.

Benchmarking a mobile browser is not a straightforward as it sounds. The developers behind the browser and/or components used in the browsers, develop their software to perform exceptionally well on their own benchmark. 

The five most popular browsers on Android, see table below:

Browser	Layout engine	JavaScrip engine
Chrome	Blink, WebKit fork	V8
Dolphine	Dolphine engine, WebKit fork	Unknown
Firefox	Gecko	SpiderMonkey
Opera	Blink, WebKit fork	V8
UC Browser	U3, WebKit fork	Unknown

As you can see both Chrome and Opera rely on the same layout engine and JavaScript engine, with only minor differences in versions, and proprietary patches. Since similar technologies produce similar results, it is reasonable to expect similar benchmark results.

Firefox is the only browser that uses a layout engine not forked from WebKit.

Both UC Browser and Dolphine, use their own WebKit fork. It is not public how much they have diverged from the original code. This means we only can make inferences based upon variations in benchmark results.

Benchmark methodology 

All test where done on a Sony Xperia Z: model C6603, running Android 4.4.2. All power management features where disabled and before every test the phone was power-cycled. For data only a stable WiFi connection was used. All browsers cloud based web acceleration options where turned off. The test page was loaded, and the cache was cleared, after which the test was done. All browser versions used where the latest at the time of writing.

The main three parameters tested are JavaScript performance, HTML5 performance, and CSS/HTML5 conformance.

Because of the before mentioned bias of any one particular test JavaScript performance was tested using three benchmarks: WebKit Sunspider 1.0.2 (originally developed, by Apple Inc), Mozilla Kraken 1.1 (developed by the Mozilla Foundation), and Google Octane 2.0.

HTML5 performance was tested using Futuremark Peacekeeper, and Rightware Browsermark 2.1. These test also use HTML feature conformance as part of their compound score metric. So to provide an insight into the CSS/HTML feature conformance as a standalone metric, Facebook's Ringmark 1.4.0 scores are also measured.

JavaScript Benchmark Results

The WebKit Sunspider benchmark metric is measured in milliseconds, lower is better. The original developer of this benchmark is Apple Inc. Apple's browser Safari uses Nitro as its JavaScript engine. Since non of the browsers tested use this JavaScript engine (as far as I am aware). It's result is reasonably unbiased, though somewhat synthetic. Since the executed test are separate pieces of JavaScript specifically developed for this benchmark. Also difference between the fastest and slowest browsers is just 115.3ms. Or to put it in other words UC Browser is only 8.7% slower, than Dolphine Browser. Not a noticeable difference for the user.

As with the previous benchmark, the metric is milliseconds, and lower is better. Also, it is not unexpected that the Mozilla browser obtains the best score on a Mozilla benchmark. The difference between the fastest and slowest browser is almost 2.5 seconds or 18.2% a pretty significant difference. 

The Google Octane 2.0 benchmark uses an entirely different metric, a Geometric Mean, as opposed to the previous two. Here, higher is better. Again we see that browser of the company behind the benchmark achieves the best score. 

JavaScript Benchmark Conclusion

As was expected the performance of  Chrome and Opera's are very similar in all tests. The results of the Kraken 1.1 and Octane 2.0 benchmarks are weighted two times heavier than the results of the Sunspider 1.0.2 benchmark. 

The browser overall JavaScript results:

1. Dolphine Browser 11.1.1
2. Firefox 29.0.1
3. Chrome 35.0.1916.138
4. Opera 21.0.1437.74904
5. UCBrowser v9.8.0.435 

HTML5 benchmark results

The Futuremark Peacekeeper seems heavily weighted toward fast rendering. Other components tested include: DOM operations, and text parsing. Notably Firefox scored highest in the categories HTML5 canvas drawing, DOM operations, and text parsing. But only was able to produce a rendering at an average speed 8.59 frames a second, and therefor the slowest at rendering of all browsers. UCBrowser the slowest browser overall, was able to produce 13.87 fps, and Chrome was fastest at 20.17 fps.

The highest speed at which HTML5 canvas drawing was done by Firefox at 4.02 fps, and the slowest was UCBrowser with 3.03 fps. On the desktop platform, the performance is at +30 frames, for most systems and ready to be applied on nextgen websites. On mobile however we are still some time away before the performance is good enough on a large enough portion of the platform, to be a useful addition to mobile websites.

Rightware's Browsermark 2.1 is more of a black box when it comes to understanding how it arrives at its score. But HTML5 canvas drawing and HTML5 conformity seem to be the major factors. As with the previous benchmark, a higher score is better. 

The best two browsers, Chrome and Opera have the same HTML5 conformity score of 81%, Firefox comes in at 74% and both Dolphine Browser and UCBrowser score 66%.

Facebook's Ringmark only examines the support for web standards like CSS and HTML5. It does not benchmark the speed of the browsers. All browsers, passed all the rings. This means that they support enough features to deliver a full web experience on nextgen websites.

The only difference between Opera and Chrome was that Opera supports the Ring 1 feature ''multiple audio playback'' and Chrome does not.

HTML5 Benchmark Conclusion

Since all browser had a passing score on Ringmark, and it does not measure performance, both Peacekeeper's and Browsermark's results will be weighted two times heavier.

HTML5 overall benchmark results:

1. Chrome 35.0.1916.138
2. Opera 21.0.1437.74904
3. Firefox 29.0.1
4. Dolphine 11.1.1
5. UCBrowser v9.8.0.435

Overall Conclusion

As expected Chrome and Opera performed very similar. Also the browsers seem to be optimized for their own benchmarks.

Since Google is most heavily invested in HTML5 technology, to replace Adobe Flash on the desktop and mobile. It is not unexpected that Google Chrome performs best. Only Firefox and UCBrowser still support Flash.

Since the reliance on HTML5 for mobile websites and even on most desktop websites is minimal, the JavaScript performance is weight twice as heavy.

Dolphine is the winner, followed by Chrome and Firefox on a shared second place. The performance difference is between first and second place is only minor. Opera comes in at third, and UCBrowser is last.