Planet LUG-Jaipur

25th International Conference on VLSI Design

2012-01-15T13:20:00+00:00

I attended the 25th International Conference on VLSI Design and 11th International Conference on Embedded Systems between January 7-11, 2012 at the Hyderabad International Convention Centre, Hyderabad, India. The first two days consisted of tutorial sessions, and the next three days had the conference presentations. There were also exhibit stalls from different companies.

On the first day I attended the tutorial session on SystemC AMS extensions by Markus Damm, Sumit Adhikari, and François Pecheux. Chitlesh Goorah had earlier tried to get SystemC into Fedora and Fedora Electronic Lab, but, due to licensing issues it could not be included. SystemC-AMS is now released under Apache license. Open SystemC Initiative and Accellera Unite have now integrated to become Accellera Systems Initiative. We hope to work with them to get their sources under a single free/open source software license. François Pecheux is from Laboratoire d'Informatique de Paris 6, Pierre & Marie Curie University (UPMC), Paris, France, and we already ship their free/open source EDA tools in Fedora.

On day two, I attended the tutorial session by Sridhar Arvind on 3D-ICE, a free/open source interlayer cooling emulator from Embedded System Laboratory, Ecole polytechnique fédérale de Lausanne, Switzerland. I have already been working with Sridhar, Prof. David Atienza and Alessandro Vincenzi on testing 3D-ICE on Fedora. I had built and tested the dependency SuperLU library and the 3D-ICE package before the tutorial session. Their software has already been downloaded by over 70 research labs around the world. I will push our tested changes to them. On the later half of the day, I attended a session on verification constraint complexity. Teal is a useful verification utility and connection library that has support for constraints and parameter control. The authors of the tool had agreed to release it as free/open source software, and we also ship it in Fedora.

On the following three days of the conference, I attended various paper presentations from different tracks from reconfigurable architectures to methods in AMS optimization. I met Prof. Susmita Sur-Kolay from the Indian Statistical Institute, Kolkata, India where they run Fedora in their labs. They also wished to use the 3D-ICE tool and GPU tools in their labs. I also visited the exhibit stalls meeting different people from the industry and academia. There are quite a few interesting free/open source tools that users can benefit from, and we will work in making them available in Fedora. In 2013, the conference will be held in Pune. Thanks to Red Hat for sponsoring my travel and participation at the conference.

ragsagar

2012-01-10T17:12:20+00:00

Last month itself there were talks that the final year BE/BTech results will be available by January first or second week. When it became January there were posts in various unofficial blogs that the results will be coming out by January 4th. Blogs said that on worst case it will be postponed to January 5th and they even stated the time University will be updating it in the database. But days passed, nothing happened. And this cycle is still going on. I was thinking how much traffic will they be getting during these days. I just wanted to know how much clicks they will be getting for using those particular keywords in their posts. Even if they are providing fake news they will be getting lots of hits. Even i am checking those blogs twice daily. They are exploiting students’ eagerness to know about their examination results. Let me check the increase in number of traffic to this blog after posting this. I will come up with an update to this post if there is considerable increase in number of clicks.
BTW, now one of the University site says that the results are expected to come out by January 12th.

Update: Yeah, This post did bring more than 100 hits in a single day as expected.

Tux workshop, MindSpark 2011, CoEP, Pune, Maharashtra, India

2011-12-28T12:05:00+00:00

I had conducted an introductory session on Fedora as part of the Tux workshop, MindSpark 2011 at College of Engineering, Pune, Maharashtra, India on Tuesday, December 27, 2011.

There were hundred participants distributed between the morning and repeat sessions in the afternoon. I explained about hardware architecture, system boot sequence, and discussed basic installation concepts to the participants. I then gave a demo of installing Fedora using Virtual Machine Manager. I showed them the plethora of F/OSS software that they can use, and also discussed about Fedora sub-projects, and basic project/communication guidelines. I have given them F16 ISO DVD images.

Thanks to Sanket Mehta for working with me for a month in organizing this workshop. Few photos taken at the event are available in my /gallery.

lalithsuresh

2011-12-15T10:23:16+00:00

After 3 months of intense hacking, I’m pleased to be writing about a little something I worked on for a project course here at KTH.

The premise

So we’re all familiar with Hadoop, right? It’s the little yellow elephant that provides an excellent platform for distributed computing, which is seeing rapid adoption by the industry, and involvement from major players like Yahoo!, Facebook and recently, Microsoft. Well, Hadoop and friends use the Hadoop Distributed File System (HDFS) as their underlying storage layer. Given the kind of jobs that are expected to run on top of it, HDFS is designed to store large files, and is optimised for throughput as opposed to latency.

HDFS is a single-master-server based distributed file system. Architecturally speaking, HDFS comprises of three important entities:

Clients, who read/write files from/to the filesystem.
Datanodes, which actually store the data (blocks) associated with the files.
The Namenode, which is a central server that stores all the metadata associated with the files, and blocks.

This division between metadata storage and data storage is important, because typical use cases of HDFS are data intensive, and not metadata intensive. That’s fine, but the problem is, if the Namenode crashes, the entire file system becomes inoperable because clients and Datanodes still need the metadata to do anything useful. Furthermore, since the Namenode maintains all the metadata only in memory, the number of files you can store on the filesystem is directly proportional to the amount of RAM the Namenode has. As if that’s not enough, the Namenode will be completely saturated under write intensive workloads, and will be unable to respond to even simple client side queries like “ls”. Have a look at Shvachko’s paper which describes these problems at great length and depth, on which we’ve based our work.

Long story short, the needs of the hour are:

High availability for the Namenode, i.e, no single point of failure.
Horizontal scalability for the Namenode, i.e, to handle heavier loads, one would need to only add more Namenodes to the system than having to upgrade a single Namenode’s hardware.

Our solution

In order to recover from crashes, the Namenode maintains a journal of all changes that it makes to the metadata. This pretty much involves logging every operation made to disk, and there is quite a huge piece of code related to this as well. However, the database community has been doing journaling, checkpointing and replicated storage since quite a while. So if you haven’t guessed our solution yet, here it is:

“Move all of the Namenode’s metadata storage into an in-memory, replicated, share-nothing distributed database.”

In short, Namenodes themselves are reduced to a stateless frontend to the database, and fetch state into memory only when required. This comes with the added advantage of being able to have multiple stateless Namenodes for the same filesystem namespace. We chose MySQL Cluster as our database because of its wide spread use and stability. So for the filesystem to scale to a larger number of files, one needs to add more MySQL Cluster Datanodes, thus moving the bottleneck from the Namenode’s RAM to the DB’s storage capacity. For the filesystem to handle heavier workloads, one needs to add only more Namenode machines and divide the load amongst them. Another interesting aspect is that if a single Namenode machine has to reboot, it needn’t fetch any state into memory and will be ready for action within a few seconds (although it still has to sync with Datanodes). Another advantage of our design is that the modifications will not affect the clients or Datanodes in anyway, except that we might need to find a way to divide the load among the Namenodes.

How we did it

We first dissected all the internal protocols being used in HDFS, i.e, the client-Namenode, Namenode-Datanode, and client-Datanode protocols. Next, we stripped out all the Namenode code that we didn’t need. This was pretty much the code related to journaling, checkpointing, the secondary Namenode and so forth.

Next, we identified the key data structures we needed to move to the DB. We picked the two most memory intensive data-structures to migrate first: the Inodes, and the Blocks.

Since we were heavily time constrained (three months to deliver the project and the report), we decided to focus on functional correctness first, and then optimise later. So the easiest course of action seemed to be to modify the lowest levels of the call chain, replacing reads/writes from/to memory with query, insert, update and delete operations on the DB. We developed two helper classes, one each for Inodes and Blocks, and interfaced with the DB through these methods. We used the ClusterJ connector to talk to MySQL. This obviously meant that we needed a flat row representation for Inodes and Blocks in the DB, and we had some other problems to think of as well on the way. How do we index Inodes? How do we index Blocks? What about Triplets?

All in all, we tackled the problem of scaling the Namenode with a set of design decisions which we later found to be consistent with Shvacko’s update paper on the Namenode’s scalability, except that he suggests using HBase as the DB.

Current status

Multiple stateless Namenodes run merrily, which store Inode and Block related metadata in MySQL Cluster. As a validation test, Clients can do an “ls” query to any Namenode and see a consistent view of the filesystem regardless of which Namenode updated the DB with the content.
We’re trying to ensure functional correctness using the HDFS unit tests. We got the most important ones to pass, and decided to keep some more bug fixing until later because we needed to evaluate the system as part of the course.
We’ve been evaluating the system using the Synthetic Load Generator. Horizontal scalability has been clearly achieved; adding more Namenodes improves the average number of operations per second for different work loads. With write intensive work loads, the scalability is linear in terms of total operations/sec that are executed.

Current limitations

Obviously, our work isn’t rainbows and sunshine; there’s a long way to go. Here’s what we don’t have yet and are currently addressing:

Performance improvements. With a single load-generator thread throwing requests at the Namenode, we’re within a 10th of the original Namenode’s performance because read/writes from/to memory now go over a network to a database cluster (which is OK, I guess). But with more LoadGen threads, we’re experiencing a hefty bottleneck, which I’ll describe in the next point.
The Namenode isn’t fully stateless yet. The most important data structures we’re yet to move are the DatanodeDescriptor entities and the file leases. There’ll surely be more, but these are the most crucial ones. Once full statelessness is achieved, we can eliminate the read-write locks in the code which are absolutely not needed any more in our implementation (the Namenode currently uses a multiple-reader-single-writer concurrency model). Profiling experiments indicated that the Namenode spends around 70% of its time waiting to acquire write locks. If we keep the Namenode fully stateless, we can wrap FSNamesystem operations into Database transactions which can be batched, and let MySQL cluster handle serialisability for us (which can handle write-heavy transactions really well). We can even break away from the single-writer model that the Namenode currently uses. Will this lead to a higher throughput for write operations than the original Namenode? Maybe.
Clients and Datanodes have to be statically partitioned as of now (it sufficed for our evaluations). We need a way for them to pick a random Namenode to perform their operations with.

Talk is cheap, show me the code!

The code is publicly available here for thy scrutiny. You’ll also need to have a MySQL cluster setup in order to test this (we have a hard coded set of defaults in DBConnector.java which you can politely ignore). Here’s our presentation on it as well. We’ve dubbed our prototype implementation KTHFS (because we’re students at KTH, but yes, no points for creativity on that one).

Future work

As an academic obligation, here’s future work (and no I’m not going to write stuff we’ll never do).

One member (not me) from the team will be continuing this work as part of his Masters thesis, and plans to address the above mentioned limitations as part of his work. I’ll try to contribute as well during my free time (what are weekends for anyway?). Let’s see how this goes.

Travel: Wai and Mahabaleshwar, Maharashtra, India

2011-12-13T09:40:00+00:00

I had been on a weekend trip to Wai and Mahabaleshwar, Maharashtra, India. More photos in my /gallery.

Fedora workshop at Foresight Institute, Pune

2011-12-04T10:15:00+00:00

I had conducted a one-day introductory workshop on Fedora at Foresight Institute of Management and Research, affiliated to University of Pune, Maharashtra, India on Saturday, December 3, 2011.

I started the day's proceedings with an introduction to free/open source software. Most of the students who participated were studying towards their bachelor's programme in computer applications (BCA), and were familiar with C, C++ and Java development. I gave a demo of the Fedora desktop, and also showed them the plethora of software that they can use.

I also introduced them to revision control with examples on using git. I also addressed the various communication tools that we use, the basic communication guidelines, and the Fedora sub-projects that they can participate in.

During the post-lunch session, I explained to them about copyright, trademarks, and licensing, and how to use them. I explained the basic concepts in installation, and gave them a demo of installation of Fedora. I have given them CD/DVD images of both Fedora 15 and 16.

Thanks to Antriksh Shah for working with me for a month in organizing this workshop.

solution

2011-11-15T15:41:03+00:00

After moving to Europe for my masters, I’ve been accustomed to finding my way around cities using the subway trains. They’re convenient, relatively cheap (unless you’re in Stockholm, where using the word cheap throws an exception), and usually fast enough as well. The only problem I have with metros is that they’re boring as shit to travel in, especially when you’re alone. Sure you can carry a book with you or invest in a tab/pad/slate/smartphone/whatever, but we definitely need to do something about the view from the windows.

Given that there’s hardly anything interesting about rocks and the occasional flash of light in a metro tunnel, I think there’s a lot that can be done to make the metro experience better. Here’s one idea I have to solve this international crisis which is oh-so-more-important than anything else on this planet. I call it, metro cartoons (the animated ones).

The basic idea is to insert cartoon panels between the tunnel walls and the tracks. Since we know the approximate speed at which the trains move, you can estimate the minimum spacing between the panels that would be required to provide a reasonable frame rate required for the animation. I’m sure artists understand these aspects better (thus, I don’t), and can come up with the right kind of drawings for this setting.

What say? I’m pretty sure someone must have tried this already, so let me know if you’ve heard of any such attempt.

Shakthimaan's Tweets

2011-11-14T06:10:00+00:00

Shakthimaan's tweets are now available for reference at http://www.shakthimaan.com/links/tweets.html. I use identi.ca and twitter for documentation links, book references, and useful tips. I am now making it available for others as well. You can also get the sources at:

  $ git clone git://gitorious.org/shakthimaan-tweets/mainline.git

Emacs ERC nick notification

2011-11-13T02:40:00+00:00

I use the following code in .emacs with Emacs ERC to get notified using notify-send whenever anyone pings me on IRC:

(defun erc-global-notify (matched-type nick msg)
  (interactive)
  (when (eq matched-type 'current-nick)
    (shell-command
     (concat "notify-send -t 8000 -c \"im.received\" \""
             (car (split-string nick "!"))
             " mentioned your nick\" \""
             msg
             "\""))))
(add-hook 'erc-text-matched-hook 'erc-global-notify)

FUDCon Pune - Design Work

2011-11-12T18:30:00+00:00

As part of the FUDCon Pune 2011 organizing team, I had volunteered to help with design work. After attending few training sessions on Inkscape by Máirín Duffy, I decided to give it a try. Ian Weller had written a Python script to create name badges with Inkscape. It would read list of names from a comma separated file (csv) file, and would generate pdfs from the design provided in the svg file. I had customized the script with help from Dave Malcolm, created csv files for speakers, volunteers and registered delegates, and generated over 400 named badges for the FUDCon event.

Thanks to Kushal Das for the photograph.
Badges printed on green paper would be for volunteers and organizers, while those printed on blue paper were for speakers. Everyone else got their names printed on white paper. We had also printed badges with just the FUDCon Pune logo for people who register at the venue to write their names on it. We decided not to use QR codes. If we had data on the delegates such as t-shirt size, food preference, identi.ca/twitter feed, IRC nick names, we could have printed them on the badge as well. I did leave enough white space, so people could write whatever they want. The scripts, the Inkscape svg design, an example csv and sample pdf generated are available at http://shakthimaan.fedorapeople.org/docs/fudcon. I had also designed the coupons for lunch, day I and II, and for the FUDPub:

FUDCon Pune - Final Day

2011-11-08T03:45:00+00:00

As a follow-up to my talk on QUCS on day II of FUDCon Pune 2011, I wanted to create circuit examples on the final day from a text book that was being followed for basic electrical engineering course work. This would be a supplement that a student can use when learning circuit theory. Anuj More and Payas Awadhutkar joined in, and we worked on schematics from chapter I of 'Fundamentals of Electrical Engineering' by Leonard S. Boborow, a.k.a "Babu Rao" in India. The schematics were created in qucs-0.0.16, and are available from Payas Awadhutkar gitorious repo:

  $ git clone git://gitorious.org/qucs-baburao/qucs-baburao.git

As a finale to the event, Jared Smith cut the Fedora cake!

I would like to thank all the volunteers from College of Engineering, Pune and Prof. Abhijit A M who coordinated with us in organizing this conference. Thanks also goes to the Fedora contributors who helped in getting things done. Special thanks to Red Hat for sponsoring the event, and for their wonderful support. The COEP volunteers:

We trained many students over the years as part of the Fedora project. I was very happy to see them as speakers and present on the things that they have been working on, and also help others when required during the conference. This is the best outcome that I take from the event.

All the photos taken at FUDCon Pune 2011 are available in my /gallery.

FUDCon Pune - Day II

2011-11-07T17:40:00+00:00

I arrived early again on day II of FUDCon Pune 2011. The day's proceedings started with a keynote by Harish Pillay on his thoughts on community work, and on his new role as the lead of Community Architecture. I then attended the 'Security in the Open Source world!' talk by Eugene Teo and Huzaifa Sidhpurwala. Their talk covered quite a bit on the various security threats, and on how they are handled.

Since I attended the GlusterFS overview talk on the first day, I wanted to follow it up with the 'GlusterFS: Hacking HOWTO' talk by Amar Tumballi. He suggested newbies to read on translators as a starting point to work with Gluster, along with few ideas that they could start with. Lunch was again served at 12 noon. After lunch, I headed to Seminar Hall 2 for my talk on 'Quite Universal Circuit Simulator - A Qt Love Story' (QUCS). It is an introduction to electrical circuit theory using circuit components as "fictional" men and women. The example circuits were created using qucs-0.0.15. The examples are available at the gitorious repo:

  $ git clone git://gitorious.org/qucs-a-qt-love-story/qucs-a-qt-love-story_prj.git

After my talk, I went to the auditorium to attend the talk by Amit Shah on 'Linux Virtualization' followed by Kashyap Chamarthy's talk on 'Virtualization with Libvirt'. They had given a good overview of virtualization in the Linux kernel, and available tools that one could use. I do use Publican, and thus attended Jared Smith's talk on the same. Publican does insert blank pages to ensure that new chapters start on the right-hand side if the content were to be printed as a book. For the final talk of the day, I attended Rahul Sundaram's session on Askbot for Fedora, and the roadmap and features that he is interested in. We then travelled to Hotel Parc Estique for the FUDPub!

FUDCon Pune - Day I

2011-11-07T12:40:00+00:00

I arrived early on day I of FUDCon Pune 2011 to help with the registration desk. We had different counters for speakers and volunteers, and for delegates. A printer was available for us to print badges, directions, or posters as required.

I attended the keynote by Jared Smith, the Fedora Project Leader. The illustrations used in his presentation, 'Fedora "State of the Union" Address' were really good. I then proceeded to the classrooms to attend Ramakrishna Reddy's talk on 'Developer Survivor Manual'. He addressed essential things that newbie developers need to know, and demoed various revision control systems. Fedora banners were placed at various seminar locations on campus to indicate where the talks and sessions were being held.

Lunch was served at 12 noon, and then I moved on to attend the 'Fedora Remix and the Community' talk by Danishka Navin. He shared his experience with the Hanthana project, which is a Fedora remix that has support for Sinhalese, and Tamil and has been deployed at various schools in Sri Lanka. Fedora is one of the first and largest user of gitolite, and I was happy to meet its author, Sitaram Chamarthy, from TCS Innovation Labs, Hyderabad, India. His talk was filled with numerous examples from people using gitolite. The other large users of gitolite are KDE and kernel.org. I then attended the 'GlusterFS' talk by Krishna Srinivas from Red Hat, who gave an overview of the Gluster file system, its architecture, and uses.

Going to FUDCon Pune

2011-11-04T00:05:00+00:00

I had filed a ticket year-end of 2009 to Fedora India to organize a FUDCon in India. We couldn't make it in 2010, but it is happening this year!

lalithsuresh

2011-10-31T21:05:05+00:00

Lagom (pronounced [ˈlɑ̀ːɡɔm]) is a Swedish word with no direct English equivalent, meaning “just the right amount”. – Wikipedia

If you’re in Sweden and there’s one word you should know, it would be ‘lagom’, a word that defines the essence of everything that is Swedish.

More than two months into Stockholm and I must say it’s been pretty lagom so far. The city itself is beautiful, with the only downside being that everything is at least twice as expensive as in Lisbon. Maybe that’s what you get for everything around here being so perfect and systematic. And unlike Lisbon, you actually have easy access to a *large* collection of beers, which is definitely a plus.

It’s autumn here right now, and the scenery outside is fabulous. Sadly though, the weather in Sweden is not-so-lagom. Temperatures are already hovering around 5 degrees celsius, and for an Indian like me, this is pretty cold in itself (heck, it never gets lower than 20 in my town back home). The funny thing is, this weather is cute for the Swedes. Let’s see how winter ends up looking like.

Meanwhile, here are some pictures I took from Stockholm over the last two months.

lalithsuresh

2011-10-21T11:01:12+00:00

We’re organising the fourth annual Workshop on NS-3, to be held in conjunction with SIMUTools 2012. The workshop will be held on March 23rd, 2012, in Sirmione, Italy. Details regarding the important dates, submission guidelines, and the scope of the workshop is available on the WNS3 2012 site.

The workshop serves as an annual gathering of ns-3 users and developers to share ideas, and brainstorm over future directions for the project. We’re inviting conference style full paper submissions, which will be made available in the ACM and EU digital proceedings. Furthermore, we’re also hosting an interactive session comprising of demos and posters. So start working on your papers and proposals as soon as possible! If you have any queries, feel free to contact the workshop chairs.

Like previous editions of the workshop, we also plan to conduct a day long ns-3 developers’ meeting around the same time. More details will be out soon. Keep an eye on our mailing lists and website to not miss any announcements.

Important dates

Papers submission deadline : December 2, 2011
Notification of acceptance : January 20, 2012
Camera-ready deadline : February 10, 2012
Demos and posters proposal deadline : February 24, 2012
Workshop in Sirmione : March 23, 2012
Developers’ meeting : TBA

presentations

2011-10-16T18:52:19+00:00

YANC 4: Deciphering academic presentations

lalithsuresh

2011-10-12T22:34:25+00:00

Having been busy with coursework lately, I hadn’t gone through our users’ list in a while. Wading through a week’s worth of posts today, it seems to me like a good deal of questions are from users who are trying to get started with extending ns-3. This is indeed quite expected; as a research tool, ns-3 is most useful only when built upon. These extensions usually take one of the following forms:

a tweak to an existing protocol to make it simulate some specific scenario (try searching for “attacks” on our users list),
adding some functionality X to an existing module, (for instance, RRC messages support for LTE)
or writing an entirely new module from scratch.

Before you do *anything* with ns-3, go through the tutorials first.

Now, for cases 1 and 2 mentioned above, the *only* way to proceed is:

Go through the literature about what you’re trying to implement — “What do I want to achieve?”
Understand the scope and limitations of the ns-3 module you’re trying to deal with (go through the model documentation at least) — “Does ns-3 have the necessary base for me to build on top of?”
If the answer to the above is “yes”, then start reading through the respective module’s code to figure out where you’ll need to insert your modifications. — “Where does my extension/tweak fit within the existing source code?”
Implement.
Profit.

Case 3, on the other hand, requires a lot more work:

Go through the literature about what you’re trying to implement — “What do I want to achieve?”
Understand how your module would fit within ns-3. This is usually the tricky part. To this end, it’s very important to understand how packets flow through a node within ns-3. This figure from our manual is usually the only thing you’ll need to know to get started.
At this point, I’ll make things easier for myself and assume that you’re going to implement something that fits into the above mentioned architecture (rather than trying to modify the architecture itself). The first step is as simple as deriving from the right class. This gives you the virtual methods you need to implement in order to maintain a particular component’s semantics. So if you’re trying to write a new application, derive from ns3::Application. If it’s a new routing protocol, derive from ns3::Ipv4RoutingProtocol or ns3::Ipv6RoutingProtocol. If it’s a new NetDevice, derive from ns3::NetDevice. The easiest thing to do is to find another example of the component type you’re trying to develop and reflect its basic structure.
Now to get started writing your new module, have a look at Gustavo Carnerio’s create-module.py script (inside src/) which generates a skeleton for your new module. This includes the necessary sub-folders for the module, and also the all important wscript file. For most use cases, it would suffice to peek into some other module’s wscript file to get an idea of what to do. If you’re going to need some fancy external libraries, you’ll need to go through the waf documentation a bit. Look into src/click/wscript to get an idea of how to do external linking.
Now once you start developing your new simulation model, you’ll need to attach this object to a node to get it to do something. This mode of attachment varies from component to component. Some objects are ‘aggregated’ to the node, some are added to a list of similar components (like applications being added to a node’s ‘ApplicationList’) and so forth. The best places to look in order to understand this are the helpers for each module. So for instance, if you want to figure out how to add your routing protocol to a node, look at src/olsr/helper/ to get an idea.
Lastly, you’ll need to write simulation scripts to see your module in action. Copying off and editing existing example scripts from the examples/ folder or the src/*/examples/ folders should suffice for most cases.
If you’re going to propose this new module for merge, look at our contributing code page. Keep in mind that we won’t merge code which doesn’t have any documentation, or tests (validation or unit tests, as is applicable).
Merge.

Fedora Activity Day II, Pune, 2011

2011-10-10T07:45:00+00:00

In preparation to FUDCon, Pune 2011, we had organized our second Fedora Activity Day (FAD) at the FOSS Lab, College of Engineering, Pune, India on Saturday, October 8, 2011. Thanks to COEP for hosting the FAD, and to Prof. Abhijit for working with us in organizing the same. Saleem Ansari had setup http://fudcon.in using Conference Organization Distribution, which we used it for registration at the venue.

Prasad Pandit started the day's proceedings with an introduction to Python. Basic syntax, semantics of Python were covered, and we helped the participants in getting started in writing simple scripts. I then presented an overview of contributing to Fedora using the i-want-2-do-project. tell-me-wat-2-do-fedora presentation, and the various communication channels that they need to be familiar with to work with the larger Fedora community.

We had lunch at the COEP Boat Club canteen. After lunch, Kashyap Chamarthy presented KVM virtualization in Fedora illustrating examples using libvirt and virt tools. Amit Shah and Kashyap answered queries regarding virtualization. Saleem Ansari then presented an introduction to web development and Django, illustrating the use of model, view and template design. I concluded the day's sessions with an introduction to git using the di-git-ally managing love letters presentation.

Few photos taken at the event are available in my /gallery.

Shaastra 2011, IIT Madras

2011-10-03T10:10:00+00:00

The Shaastra team has been trying to get me to speak at their event for many years. This year I wanted to make it, and as part of the Hackfest at Shaastra 2011, September 28 to October 2, 2011 at IIT-Madras, Chennai, India I had presented the talk on i-want-2-do-project. tell-me-wat-2-do.

Most of the students were interested in participating in the Google Summer of Code program. I was also able to meet and talk with past Google Summer of Code students, who had already been introduced to this presentation.

I visited the IITM Research Expo at the K V grounds on campus where students had presented their research work. There were quite a few interesting papers on MEMS. I also attended the Paper and Poster presentation by students at the IITM Research Park. A small memento that I received:

Fedora Activity Day I, Pune, 2011

2011-09-25T06:30:00+00:00

In preparation to FUDCon, Pune 2011, we had organized a Fedora Activity Day (FAD) I at Red Hat, Pune, India on Saturday, September 24, 2011.

Rahul Sundaram started the proceedings with a session on how to contribute to Fedora, and how people can get involved with the community. I showed the various communication channels that people need to use to connect with the large Fedora community.

We then proceeded to do a hands-on session on RPM packaging. We used the GNU Hello RPM packaging example from the fedoraproject.org wiki. Rahul and I explained each section of the .spec file, and showed them how to use rpmbuild. The participants learnt to write the .spec file, and also built, installed, and tested the hello package.

We then took a break for lunch following which I presented a hands-on session on git using the di-git-ally managing love letters presentation. Siddhesh Poyarekar then took an introductory hands-on session on autotools.

All the presentations are available in the FAD wiki page. Thanks to Red Hat for letting us use their facility, and for sponsoring the pizza! They were able to arrange for ten laptops with Fedora 15 installed for participants who didn't have laptops.

Thanks also to Kashyap Chamarthy, Kushal Das, Siddhesh Poyarekar for their help to the participants during the workshop sessions.

From Python to Silicon: python-myhdl

2011-09-20T04:10:00+00:00

I had presented From Python to Silicon: python-myhdl talk at PyCon India 2011, September 16-18, 2011 at Symbiosis, Pune, India.

The first day of the (un)conference was filled with tutorials. I attended the Functional Programming with Python talk by Anand Chitipothu. He had illustrated list comprehensions, recursions, higher-order functions, iterators and generators in Python with numerous examples.

On the second day, I attended the keynote by Raymond Hettinger on What Makes Python Awesome. It was a very informative talk illustrating the key characteristics of Python, and the community that surrounds it.

I also attended the Python on Android talk by Sajjad Anwar, who gave simple examples using android-scripting. The Emacs as a Python IDE talk by Noufal Ibrahim had useful tips and tricks on using Emacs for development work, and issue tracking using org-mode. I also attended the Decorators as Composable Abstractions by Sidhant Godiwala which was an introduction to using decorators in Python.

On the final day of the event, I attended Network Programming with Umit Project by Narendran Thangaranjan who gave demos on network protocol implementation, and testing in Python using the Umit project. Jivitesh Singh Dhaliwal gave a demo of using PySerial to control robots in the Python in the Real World: From Blinking LEDs to Advanced Robotics talk.

My presentation slides are available. Thanks to Christopher Felton for his valuable feedback.

Few photos taken during the event are available at my /gallery.

Packaging RPM

2011-09-10T03:40:00+00:00

Released Packaging RPM (Packaging Red hot, Paneer (butter) Masala) presentation 1.7. The LaTeX sources are available at gitorious.org.

  $ git clone git://gitorious.org/packaging-red-hot-paneer-butter-masala/mainline.git

seals

2011-09-09T16:20:06+00:00

3. YANC – Seals

dido

2011-08-29T15:37:40+00:00

2. YANC - Utility

Introduction to GNU Make

2011-08-29T08:40:00+00:00

I had presented GNU Make, Dum Ka Biryani, Make for each other at ICE-FOSS 2011, August 26-27, 2011 at Federal Institute of Science and Technology, Angamaly, Kerala.

The conference had talks, hands-on workshops, and project demos. There were interesting projects displayed at the stalls by the students varying from Arduino-based hardware projects, to Python mobile application development to games, and applications developed using opencv. Pamphlets were made for each project, and given to the visitors at the stall. I reviewed the projects that were demoed and gave them feedback. The Institute is in the process of migrating their servers, so we should (hopefully) see the sources made available online.

I also had a chance to meet Anvar K Sadath, Executive Director at the IT@School project. They have trained nearly 2 lakh teachers on F/OSS over the years. Their new initiative is animation training using free/open source software.

The Institute does have a cluster setup called "Dakshina" which is used by students, and the faculty. They also do allow other nearby colleges to use the facility on request.

Thanks to the Management of FISAT, for sponsoring my travel and for the wonderful hospitality. Photos taken during the trip are available at my /gallery.

Introduction to TDD, BDD: Pune Institute of Computer Technology

2011-08-22T05:20:00+00:00

I had conducted a session on test driven, behaviour driven development on Saturday, August 20, 2011 at Pune Institute of Computer Technology, Pune, Maharashtra, India using Ruby, Cucumber, and Rails with examples from Diaspora.

Thanks to Praveen Arimbrathodiyil for initiating this workshop and Shreyank Gupta for helping the students during the hands-on session.

Participants were new to Ruby, and we started off with Ruby in Twenty Minutes. Using interactive ruby (irb) students were able to understand the language syntax and its usage. We then moved on to writing tests in Ruby, and writing them first before writing code.

User stories were introduced with explanation on understanding how features, and step definitions are written. Cucumber was used to run through the features with simple examples. We then moved on to using cucumber with Rails illustrating an example of a Rails blog application. I had setup Diaspora on my laptop, and had then given them a visual demo of how cucumber runs feature tests with selenium webdriver. Photos taken from Shreyank's camera are available.

ragsagar

2011-08-21T16:13:03+00:00

A script written by Adhil Azeez to generate Indian flag in php. Actually he wanted to share the code here on Independence day. But i was not able to post it that day. After that a series of things happened that prevented me from getting online and updating my blog. So here is the code..

<?php
/*
 * Filename: tricolor.php
 * Dependencies: GD Library mostly precombile with php 4.0+
 * Author: Adhil Azeez NV
 * Description: Generates Indian National Flag Image
 */

//Create a resource identifier for the image res in ration 3:2
$flag = imagecreate(1350, 900); 
if (!$flag) {
    die("Some error occured");
}
//Color identifiers definitions
$white = imagecolorallocate($flag, 255, 255, 255);
$saffron = imagecolorallocate($flag, 255, 153, 51);
$green = imagecolorallocate($flag, 18, 136, 7);
$blue = imagecolorallocate($flag, 00, 0, 137);

//Draw the tricolor sections.The white portion is no need to be specified since
//the background color is white.
imagefilledrectangle($flag, 0, 0, 1350, 300, $saffron);
imagefilledrectangle($flag, 0, 600, 1350, 900, $green);

//Draw the Ashoka Chakra
//The Circle can be created with imageellipse itself after setting the thickness.
//But unfortunetly due to a bug in GD library(reported more than 5 years ago :()
//the thickness is being ignored.
imagefilledellipse($flag, 675, 450, 240, 240, $blue);
imagefilledellipse($flag, 675, 450, 210, 210, $white);

//Draw the center small circle
imagefilledellipse($flag, 675, 450, 42, 42, $blue);

for ($angle = 0; $angle <= 360; $angle = $angle + 15) {

//Draw 24 small circles in the Ashoka Chakra at the border of the circle adjacent
// to 24-spoke
    $x = 675 + 105 * cos(deg2rad($angle+7.5));
    $y = 450 + 105 * sin(deg2rad($angle+7.5));
    imagefilledellipse($flag, $x, $y, 10.5, 10.5, $blue);

//Draw the 24 spooks
    $x1 = 675 + 8 * cos(deg2rad($angle));
    $y1 = 450 + 8 * sin(deg2rad($angle));
    $x2 = $x1 + 40 * cos(deg2rad($angle - 5));
    $y2 = $y1 + 40 * sin(deg2rad($angle - 5));
    $x3 = 675 + 105 * cos(deg2rad($angle));
    $y3 = 450 + 105 * sin(deg2rad($angle));
    $x4 = $x1 + 40 * cos(deg2rad($angle + 5));
    $y4 = $y1 + 40 * sin(deg2rad($angle + 5));
    imagefilledpolygon($flag, array($x1, $y1, $x2, $y2, $x3, $y3,$x4,$y4), 4, $blue);
}
//if the script being invocked from CLI and has a filename arguments then write
//the out put to the file else print to the outputstream.
if (isset($_SERVER['argv'][1])) {
    if(imagejpeg($flag, $_SERVER['argv'][1] . '.jpg', 100))
    	echo "National Flag saved to ".$_SERVER['argv'][1] . '.jpg';
    else
    	echo "Some error occured";
} else {
    header("Content-type: image/jpeg");
    imagejpeg($flag, null, 100);
}
imagedestroy($flag);
?>

Design

The script makes use of php GD library. It outputs the image to current
output stream or save to a file.

If php GD library have anti aliasing support then we can enable that for much
better render.Currently anti aliasing is not enabled in the script.

The output is in JPEG format but it can be changed to other format if necessary
with a few modification in the script.

Dependencies
PHP needs GD Library support. Most of the php distribution compiled with it.

Usage
php flag.php filename

Filename argument is optional. If not present the script will output to the
current output stream

for example:
php flag.php | display
will open the image in ImageMagick picture viewer

Setting alarm at a particular time

2011-08-15T08:34:22+00:00

My ISP provides unlimited download from 2am to 8am. So i was not able to sleep after 2 from the time i switched to the new broadband plan. Keeping the system on and setting a cronjob to start downloading after 2 was an option. But i was more concerned about the increasing electricity charge, than my sleep. Besides it is my social responsibility to save energy as a gonna-be software engineer :p. After a bit of googling and hacking i was able to wake up my system at a particular time. Here i am going to explain how i made my arch linux system to boot automatically at 2 am.

The configuration is done in Arch Linux. For automatic wakeup it needs a BIOS which supports RTC alarm. Most of them manufactured after 2000 supports this feature.

1) Check if your BIOS supports automatic wakeup

Execute the command below as root.

# grep rtc /var/log/messages.log
rtc_cmos 00:03: RTC can wake from S4
rtc0: alarms up to one month

If you can find something like this in the output.It says that the system can wakeup and a wakeup time can be setup.

2) Enable automatic wakeup in BIOS

Go to your BIOS setup, Under Power Management search for something like “Wake by RTC Alarm” or “Resume by RTC alarm” or “RTC resume”.Then enable it.

3) Set the hardware clock time standard as UTC

Edit the /etc/rc.conf file as root and set the HARDWARECLOCK variable to UTC

[ragsagar@h4ckb0x ~]$ grep ^HARDWARECLOCK /etc/rc.conf
HARDWARECLOCK="UTC"

Make sure that your timezone is set correctly in /etc/rc.conf
More help : https://wiki.archlinux.org/index.php/Time

4) Set the alarm time

Execute the following commands as root

# echo 0 > /sys/class/rtc/rtc0/wakealarm
# echo `date '+%s' -d '+ 5 minutes'` > /sys/class/rtc/rtc0/wakealarm

This will set the the alarm time as 5 minutes into the future.

Now run

$ cat /sys/class/rtc/rtc0/wakealarm

If the output of above command is something like “1313383930″, the alarm is set. It is epoch time. If it doesn’t yield any result make sure that the HARDWARECLOCK variable is set to UTC and reboot and try again to set the alarm time.

Now run

$ cat /proc/driver/rtc

Go through rtc_time, alrm_time and alrm_date and check if they are correct(will be in UTC).Turn off the system and leave the power on. Check if the system is booting automatically after five mintues.

5) Setting the alarm to a particular time and date.

To set the alarm to woke up the system at 16th Aug 2:05am, Run the following as root

# echo 0 > /sys/class/rtc/rtc0/wakealarm
# date --date "Aug 16 , 2011 02:05:00" +%s > /sys/class/rtc/rtc0/wakealarm

You can convert the epoch time to readable format and check the alarm time is correct.

[root@h4ckb0x ragsagar]# cat /sys/class/rtc/rtc0/wakealarm
1313440500
[root@h4ckb0x ragsagar]# date -d @1313440500 +%F" "%T
2011-08-16 02:05:00

Note : The mythtv wiki about acpi wakeup says that setting the hardware clock after setting alarm will disable the alarm while most of the linux distribution sets hardware clock during shutdown. They suggest to disable hardware clock adjusting during shutdown. To do that in Archlinux set the HARDWARECLOCK=”" in /etc/rc.conf . But in my arch system the alarm was not working when i set HARDWARECLOCK=”" whereas it worked when i gave HARDWARECLOCK=”UTC”. So if the wake up alarm is not working do try after changing the value of this variable.

To start downloading when the system boots up, i added a cronjob to restart the router at 2:15 and 7:45 (to account the download in happy hours). Also added “transmission-gtk” to the gnome-session-properties. So that transmission will be launched on startup and downloading will be started.

Reference :

http://www.mythtv.org/wiki/ACPI_Wakeup

https://wiki.archlinux.org/index.php/Time

ERC

2011-08-13T12:15:00+00:00

ERC is a modular, extensible Emacs Internet relay chat client. It is available as part of GNU Emacs. You can use it to connect to irc.freenode.net (for example) chat server using:

;; .emacs
(load "/path/to/secrets.el")

;; erc
(defun erc-freenode-connect ()
  (interactive)
  (erc :server "irc.freenode.net" :port 6667 :full-name "" 
   :nick "")
  (require 'erc)
  (require 'erc-match)
  (setq erc-keywords '(""))
  (setq erc-current-nick-highlight-type 'nick)
  (setq erc-track-exclude-types '("JOIN" "PART" "QUIT" "NICK" "MODE"))
  (setq erc-track-use-faces t)
  (setq erc-track-faces-priority-list
	'(erc-current-nick-face erc-keyword-face))
  (setq erc-track-priority-faces-only 'all)
  (setq erc-input-line-position -2)
  (setq erc-echo-notices-in-minibuffer-flag t)
  (setq erc-autojoin-channels-alist 
	'(("freenode.net" "#fedora-india" "#fedora-devel" "##linux-india" 
            "#edev" "#fedora-arm" "#fedora-haskell" "#fudcon-planning" "#gcc"
  	    ))))

(defun nickname-freenode-after-connect (server nick)
  (when (and (string-match "freenode\\.net" server)
	     (boundp 'irc-freenode-nick-passwd))
    (erc-message "PRIVMSG" (concat "NickServ identify " irc-freenode-nick-passwd))))
(add-hook 'erc-after-connect 'nickname-freenode-after-connect)

The secrets.el file loads your encrypted files that contain passwords:

;; secrets.el
(load-library "~/pass.el.gpg")

A sample pass.el.gpg file:

;; pass.el.gpg
(set 'irc-freenode-nick-passwd "your-password")

The first time you load the above, you will be prompted to create a password for the encryption. Remember it. Whenever you start Emacs thereafter, or when you try to modify the .gpg files, you will be prompted for the password. To initiate connection to irc.freenode.net within Emacs, you can use:

M-x erc-freenode-connect

It should connect to the server, join you to the channels, and identify yourself to NickServ! Each channel is a buffer, and thus Emacs buffer commands work. Whenever someone sends you a message using your nick, you will get a notification in the Emacs status bar. For more ERC commands and options, please refer the ERC user manual.

ragsagar

2011-08-13T00:23:50+00:00

A slightly edited version of the script to restart router written by Madhusudan.C.S to make it work with teracom router given by bsnl.

#!/usr/bin/env expect

set username admin
set pass admin
set host 192.168.1.1

spawn telnet ${host}

expect -re "Login:"
send "${username}\r"

expect "Password:"
send "${pass}\r"

expect -re "successful"
send "console enable\r"
send "restart\r"
expect eof

Introduction to Python: Maharashtra Institute of Technology

2011-08-08T07:10:00+00:00

I had conducted a one-day hands-on "Introduction to Python" programming workshop at Maharashtra Institute of Technology, College of Engineering, Kothrud, Pune, India on Saturday, August 6, 2011.

The participants were engineering students who had some programming experience but were new to Python. I wanted to do a hands-on session so I could help them along the way. I decided to use the presentation Python: Introduction for Programmers by Bruce Beckles and Bob Dowling from the University Computing Service, University of Cambridge. I had requested permission to re-use the slides giving credit to the authors, for which they agreed.

Two software labs (I and II) were made available at the venue. Remote desktop was setup so the slides were visible on both the lab projectors. A speaker system was arranged so people could hear me from either lab. Gedit was used to write simple programs.

Thanks to Prof. Reena D. Pagare (MIT, College of Engineering) for working with me during the last few weeks in organizing this workshop.

More photos taken at the venue and during the workshop are available at my /gallery.

comic-simulator

2011-08-07T12:33:05+00:00

I always wanted to do comics, so here’s a hello world:

1. YANC – A bad networking researcher…

EasyPG

2011-08-05T06:45:00+00:00

EasyPG, a GnuPG interface is available from Emacs 23 which provides automatic encryption of .gpg files. You can list all the required encrypted .gpg files to be used by Emacs in a secrets.el file (for example):

  
  ;; secrets.el
  (load-library "~/pass.el.gpg")

You can then load this file in your Emacs initialization file:

  
  ;; .emacs
  (load "/path/to/secrets.el")

lalithsuresh

2011-08-03T14:40:58+00:00

Recently, a teacher at my alma mater turned barber and forcibly cropped the hair of over 90 students who didn’t follow the school’s code of conduct for haircuts (we didn’t even know there was one during our days). Obviously, the students, parents and locals weren’t amused by this barb-er-ic act. Neither were those of us who are proud of being former students of that school.

Indian educational institutions have always been rather conservative in their organisation. There is all too often a strict hierarchy visible in the way things work. Teachers have a commanding authority over students, and it’s common for students to stand up and say “good morning/afternoon/whatever” in unison when the former enters a classroom. Failure to do so is often seen as an act of disrespect. In many schools, even at a high school level, you find that students are expected to form and walk only in a line when moving from one classroom to another. I’ve seen institutions with really silly dress codes, like “boys should only wear shirts/t-shirts that *have a collar*”. There are many colleges where cell phones are banned on campus (and many that go too far to implement their policy). And there are also colleges where guys aren’t allowed to talk to girls.

There is an overflow of rules, and unnecessary requirements on conformance. I’ve had a lecturer yell at me for 15 minutes (out of a 40 minute lecture), ask me to never enter class again, and walk out of class herself in anger simply because I didn’t “write down” the last few steps of a solution to a problem she handed out in class, which I managed to solve in my head to arrive at the answer.

All the above is absolutely disgusting and is an antithesis to what is supposed to be education. We put a bunch of students into a classroom, expect all of them to conform to a strict set of rules, and punish the ones who don’t with expulsion. Ultimately, all these students end up having to take charge of society in some way or the other, and we basically leave our country in the hands of those who abide by silly dogmas, are well trained in the art of superficial respect, can’t think laterally, are used to hierarchies, and with regard to some of the specific cases I mentioned above, are incapable of working with the opposite sex.

I wonder what the net gain is from putting so much effort into running a system like this?

Our future leaders should be capable of making decisions that affect others positively. We need students to be well trained in networking with others, exchanging ideas, and communicating effectively. We need them to be open minded, embrace differences, and adapt to the pace at which the world around us is evolving. How on earth is all that supposed to happen if *this* is their education?

Furthermore, where do teachers get the time and energy to enforce such rules when they have so many important things to attend to?

Teachers have the responsibility of being a role model and not that of a dictator. All those teachers who’d inspired me over my life _strictly_ fall into the former category (from junior school, through high school, and upto where I am now). They were the ones who invested enough effort into figuring out how best to convey their ideas to their students, learned how to tap into our creative potential, and at the same time, stayed up to date with whatever it is that they were supposed to teach. They also served as moral and social instructors not through an iron fist, but through inspiration. They gave us enough room to develop, spared us the fury when we made mistakes and instead, taught us how to learn from them. They made us go “There is so much I can learn from that person!” as opposed to “That person will screw me over if I don’t do this”.

Sure, perfect pedagogy isn’t easy, but chaining students to a gratuitous set of rules is definitely not the answer. They are humans after all.

unjumbled output

2011-07-24T09:44:17+00:00

Here is a python script to find solution for a jumbled word. Give a jumbled word as parameter, it will list the possible solutions.

import sys

dictfile = "/usr/share/dict/cracklib-small"

def get_words(text):
	""" Return a list of dict words """
	return text.split()
	

def get_possible_words(words,jword):
	""" Return a list of possible solutions """
	possible_words = []
	jword_length = len(jword)
	for word in words:
		jumbled_word = jword
		if len(word) == jword_length:
			letters = list(word)
			for letter in letters:
				if jumbled_word.find(letter) != -1:
					jumbled_word = jumbled_word.replace(letter,'',1)
			if not jumbled_word:
				possible_words.append(word)
	return possible_words		
			
				
if __name__ == '__main__':
	words = get_words(file(dictfile).read())
	if len(sys.argv) != 2:
		print "python %s <jumbled word>" % sys.argv[0]
		sys.exit()
	jumbled_word = sys.argv[1]
	words = get_possible_words(words,jumbled_word)
	print "possible words :"
	print '\n'.join(words)

Don’t forget to change the ‘dictfile’ to the wordslist file you have in your system.

Here is the screenshot of script output.

Emacs-a-day-keeps-the-vi-zing-away

2011-07-18T16:35:00+00:00

Emacs-a-day-keeps-the-vi-zing-away, a GNU Emacs reference card is now available under the GNU General Public License. You can get the LaTeX sources from:

  $ git clone git://gitorious.org/emacs-a-day-keeps-the-vi-zing-away/mainline.git

freeDiameter

2011-07-07T16:25:00+00:00

freeDiameter, a free/open source Diameter protocol implementation is now available for Fedora/RHEL. Install it using:

  $ sudo yum install freeDiameter freeDiameter-devel

It fully supports the Diameter Base Protocol as specified in RFC 3588, Diameter Extensible Authentication Protocol (EAP) application server from RFC 4072, and Diameter Session Initiation Protocol (SIP) application from RFC 4740. Thanks to Sebastien Decugis for accepting the upstream patches.

MyHDL

2011-07-06T05:50:00+00:00

MyHDL, a Python hardware description and verification language is now available for Fedora/RHEL. Install it using:

  $ sudo yum install python-myhdl

A simple example of a D flip-flop is given below:

#!/usr/bin/python

from myhdl import *
from random import randrange
 
def dff(q, d, clk):
    @always(clk.posedge)
    def logic():
        q.next = d
 
    return logic
 
def test_dff():
    q, d, clk = [Signal(bool(0)) for i in range(3)]
 
    dff_inst = dff(q, d, clk)
 
    @always(delay(10))
    def clkgen():
        clk.next = not clk
 
    @always(clk.negedge)
    def stimulus():
        d.next = randrange(2)
 
    return dff_inst, clkgen, stimulus
 
def simulate(timesteps):
    tb = traceSignals(test_dff)
    sim = Simulation(tb)
    sim.run(timesteps)
 
simulate(2000)

You can run it using:

$ python test.py

The generated test_dff.vcd can be viewed in GTKWave:
You can also generate Verilog code using the toVerilog() function. For example:

def convert():
    q, d, clk = [Signal(bool(0)) for i in range(3)]
    toVerilog(dff, q, d, clk)
 
convert()

The generated Verilog code looks like:

`timescale 1ns/10ps

module dff (
    q,
    d,
    clk
);

output q;
reg q;
input d;
input clk;

always @(posedge clk) begin: DFF_LOGIC
    q = d;
end

endmodule

Refer their wiki for more documentation.

Essential Abstractions in GCC

2011-07-04T14:00:00+00:00

I have been wanting to attend the 'Essential Abstractions in GCC' workshop at IIT Bombay, Powai, Mumbai for many years, and I was finally able to make it this year (their fourth), June 30-July 3, 2011. Thanks to Red Hat for sponsoring me.

The first day started off with an introduction to the GCC Resource Center at IIT, Bombay, and their primary research interests in program analysis and optimization, translation validation, retargetable compilation, and parallelization and vectorization. They proceeded to give an overview of compiling GCC, and probing techniques used in understanding the functionality of the GNU C compiler. Lab sessions were held in the afternoon, and assignments were given to illustrate the concepts discussed. In general, lectures were scheduled in the morning, and lab sessions in the afternoon.

The second day focussed on introducing the control flow in gcc, adding passes to gcc, and manipulating GIMPLE for adding interprocedural and intraprocedural passes. Using simple GIMPLE API in gcc-4.6.0 were illustrated, along with adding static/dynamic plugin passes. The lab sessions were held in the afternoon. Teaching Assistants (students) were present to assist the participants during the lab sessions. There were regular tea breaks provided between breakfast, lunch, and dinner.

The third day began with an introduction to machine descriptions. Examples of retargetability mechanisms in gcc using spim, a MIPS processor simulator were illustrated with examples. The instructions sets were added incrementally at different machine description levels, beginning from assignment operations to arithmetic to pointers and function calls. The issues of retargetability mechanisms in gcc were also discussed.

The final day started with an introduction on parallelization and vectorization, theory, and concepts. Their implementation in gcc-4.6.0 was illustrated, specifically for the case of loops with data dependency diagrams. The use of graphite, and polyhedral compilation in gcc-4.6.0 were also discussed. We had lab assignments in the afternoon, and the session concluded with a summary of the essential concepts required in understanding the internals of GCC.

The workshop is useful if you have worked with compiler internals. I only wish they would release the sources of their work under a Free/Open Source license for everyone to benefit from.

Few photos taken during the trip are available in my /gallery.

MonadCatchIO-mtl

2011-06-29T06:55:00+00:00

MonadCatchIO-mtl, a monad-transformer version of the Control.Exception.catch function is now available for Fedora. Install it using:

  $ sudo yum install ghc-MonadCatchIO-mtl ghc-MonadCatchIO-mtl-devel

A simple example to throw or catch an exception that is an instance of the Exception class:

{-# LANGUAGE DeriveDataTypeable #-}

import Control.Monad.CatchIO
import Data.Typeable
import Prelude hiding (catch)

data MyException = ThisException | ThatException
     deriving (Show, Typeable)

instance Exception MyException

main = do
     throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))

Thanks to Daniel Gorín for the upstream changes.

lalithsuresh

2011-06-23T17:54:27+00:00

I’m officially done with the first half of my masters as of now, and it’s been a fun swim so far in the violent sea of distributed systems, which by the way, is a really big zoo where anything can go wrong. To quote Leslie Lamport:

A distributed system is one in which the failure of a computer you didn’t even know existed can render your own computer unusable”

Thus, researchers over the last few decades have gone through great lengths to design distributed algorithms that ensure correct behaviour in the light of node failures and random activity by other processes. But if you’re a student and you’re going through these algorithms, it’s not entirely obvious what some of the magic numbers mean at times, and what the intuition is behind them that ensures that an algorithm works correctly. This post is meant to help in that direction. As per distributed systems convention, N refers to the number of processes in the system and F refers to the number of failures that can be tolerated.

> N/2
This is a simple majority “quorum”. There are many algorithms that exploit the fact that two quorums overlap in at least one process. Let’s take an example to illustrate this. Consider a system with N processes, serving as a distributed replicated database. There is a single process writing to the database and there can be more than one reader. One approach to doing this would be to have the writing process write to at least replicas. If the reading process reads from at least nodes, there will be at least one replica which has seen the latest write. This can used in scenarios where only less than half the nodes can fail. Some examples include Majority ACK Uniform Reliable Broadcast, Majority Voting Regular Register, and Read Impose Write Majority (1,N) Atomic Registers.
> (N+F)/2
Referred to as “Byzantine Quorum”, this one’s a bread and butter number for many Byzantine Fault Tolerant algorithms, which are algorithms that tolerate arbitrary failures. This means that the distributed algorithm produces a correct result in spite of having processes that either do not respond, send out garbage values and so forth. The behaviour can be either due to faulty hardware, software, or due to control by a malicious user. The essence of the number itself is that any two sets of size overlap in at least one correct process. This is valid only when N > 3F (you can learn the “why” behind this from the Byzantine Generals Problem). Example algorithms: Authenticated Data Byzantine Quorum based Regular Register and Byzantine Randomised Consensus.
> (N+2F)/2
This is known as a Byzantine Masking Quorum. The intuition here is that any two quorums of size will overlap in 2F + 1 processes, thus ensuring that you have a worst case split up of F+1 correct processes and F faulty ones. Note that N > 4F is necessary for this condition to be true.This is particularly useful in the context of Byzantine Registers, and can be seen in algorithms that implement Byzantine Safe Registers. Let’s take the example of our distributed replicated database that we’d discussed above, but with byzantine faults. The writing node attempts to write to all nodes and returns from the write upon receiving ACKs from replicas. A node that needs to read from the replicated servers reads from any nodes, and only picks a value if it has more than F occurrences in the set that was read (the Byzantine process can return garbage values upon the read request). The guarantees that there would be at least F+1 correct processes in such a set so that reads that are not concurrent with a write will for sure give you F+1 correct and up-to-date values.
> F
This one is pretty straightforward, and you begin seeing this as soon as you’re dealing with algorithms wherein processes crash. If you receive a message from at least F+1 processes, then you’re sure that you’ve received the message from at least one correct process (a process that will not fail).
> 2F
Follows from the previous one, this ensures that if you receive 2F + 1 messages, you’re sure that more than one correct processes is part of this set. This is particularly seen in Byzantine Algorithms where making a decision based on > F is risky. For instance, consider situations where uniform agreement is required. One such example is that of Leader Election in a distributed system. For correct functioning of the system, it is entirely necessary that all nodes have the same view of who the leader is. The algorithm fails if two nodes have picked two different nodes as their respective leaders, and in the presence of byzantine faults, this is quite possible. Consider the Rotating Byzantine Leader Detection algorithm wherein nodes can choose to “complain” about the current leader under the suspicion of being byzantine. A node decides that it should shift to the next leader when it hears at least > 2F complaints. Here’s why we can’t use > F alone over here. Let’s assume our system should tolerate one byzantine fault (F = 1). Assume, that a process P incorrectly suspects the current leader (who is legitimate) of being byzantine and broadcasts a “complaint” message. Now a byzantine node in the same system can go against the protocol, and send process P a “complaint” message, at which point process P now has > F (2 > 1) complaints about the current leader, causing it to change leaders. Since the byzantine process sent the complaint message only to process P and not the other processes in the system (who didn’t find anything strange about the leader in order to complain), we now have process P with a leader and the remaining processes at leader such that . Byzantine process wins. On the other hand, if you rely on the 2F + 1 magic number, you’re sure that there are at least F+1 correct entries in your set.
> N-F
In algorithms where faulty nodes have the liberty of “not responding” (crash-stop processes for instance), N-F is the lowest number of responses you can hope to get if you ping all processes in the system. In byzantine scenarios, a set of N-F processes contains at least N-2F correct processes (F responses out of N-F can be corrupt). This number can be seen in many algorithms which require uniform agreement, one example being Byzantine Randomized Consensus.

That’s it for now. Do let me know if there are any errors above or any important information I’ve missed out on.

ragsagar

2011-06-15T14:11:35+00:00

Actually this is a sample question appeared in codejam contest conducted by mobme wireless. Imdbpy python module is used to retrieve movie informations from imdb.

For those who don’t know about this event : http://codejam.mobme.in/

Sample Question :

Write a program that ranks Hollywood actors based on the number of their appearances in a list of top 100 movies. There are a number of top movie lists on the Internet and it’s up to you to choose one. We’d prefer you choose one that has an open API.

Solution in Python :

#!/usr/bin/env python

__author__ = "Rag Sagar.V"
__email__ = '@'.join(['ragsagar','.'.join([_ for _ in ['gmail','com']])])


from twisted.internet import reactor, threads
import re,imdb,itertools


actors_rating = {} #actors_rating['actor name'] = rank
rank = 0
count = 1
current_rank = 0
concurrent = 5
finished = itertools.count(1)
reactor.suggestThreadPoolSize(concurrent)


try:
	imdb_access = imdb.IMDb()
except imdb.IMDbError, err:
	print err
		
top_100 = imdb_access.get_top250_movies()[:100]


def populate_actors(mid):
	movie = imdb_access.get_movie(int(mid))
	#print movie
	for i in (0,1):
		actor_name =  movie['cast'][i]['name']
		if actors_rating.has_key(actor_name):
			actors_rating[actor_name] = actors_rating[actor_name] + 1
		else:
			actors_rating[actor_name] = 1
	if finished.next()==added:
		reactor.stop()
	
added = 0
for movie in top_100:
	added += 1	
	req = threads.deferToThread(populate_actors, movie.getID())

try:
	reactor.run()
except KeyboardInterrupt:
	reactor.stop()	

   
for actor in sorted(actors_rating, key=actors_rating.get, reverse=True):
	previous_rank = current_rank
	current_rank = actors_rating[actor]
	if previous_rank !=  current_rank :
		rank += count
		count = 1
	else:
		count += 1	
	print rank,actor

Dependency :
imdbpy

ragsagar

2011-06-07T17:42:41+00:00

Here is a python script to wish you Good Morning or Good Evening according to the time of the day.

#!/usr/bin/python
import time

current_hour = time.strptime(time.ctime(time.time())).tm_hour

if current_hour < 12 :
	print "Good Morning!"
elif current_hour == 12 :
	print "Good Noon!"
elif current_hour > 12 and current_hour < 18 :
	print "Good AfterNoon!"
elif current_hour >= 18 :
	print "Good Evening!"

Now if you want to display it when you open the console add the following line to your ~/.bashrc file.

python /path/to/the/script.py

Happy Hacking!

lalithsuresh

2011-06-01T23:31:13+00:00

We now move into part II of the ns-3-click tutorial series wherein I’ll walk you through an ns-3 script and explain how to load your Click scripts onto ns-3 nodes. This tutorial goes through the following steps:

Walkthrough of an example Click graph from ns-3-click.
Using the Click graph in an ns-3 simulation.

Walkthrough of an example Click graph from ns-3-click

The Click script I’ll be explaining below is available in current ns-3-dev and stable releases from ns-3.11 onwards. You can find it in src/click/examples/nsclick-lan-single-interface.click.

When working with ns-3-click, you will need to handle all layer 3 functionalities expected of a networked node from Click. The Click script that we’ll be talking about here provides exactly this. It handles ARP, and forwards packets up and down the stack as required. It has a single network interface (eth0) to send and receive packets, and has a kernel interface (tap0) to send/receive packets from the kernel (in ns-3, this corresponds to communicating with layer 4).

We first describe the interface to tap0 with the following functionalities:

All packets received from tap0 should be forwarded down to the stack.
All packets received from below the stack, destined to us, should be sent up the stack via tap0.

elementclass TapSimHost {
$dev |

// Packets go to tap0, which sends them to the kernel
input[0]
-> ToDump(tokernel.pcap,2000,IP,PER_NODE 1)
-> ToSimDevice($dev,IP);

// Packets sent out by the kernel get pushed outside
FromSimDevice($dev,4096)
-> CheckIPHeader2
-> ToDump(fromkernel.pcap,2000,IP,PER_NODE 1)
-> GetIPAddress(16)
-> [0]output;
}

kernel::TapSimHost(tap0);

The above snippet does exactly what we’ve described so far. We create an element class which has a single input and output. Packets received on the input are plumbed to tap0 (because $dev is now tap0, as per the instantiation in the last line). Packets received from tap0 are pushed outside. We now describe a LAN host, which will handle ARP, and check the destination IP to see if we should receive the packet.

elementclass LanSimHost {
$ipaddr, $hwaddr |

cl::Classifier(12/0806 20/0001,12/0806 20/0002, -);
forhost::IPClassifier(dst host $ipaddr,-);
arpquerier::ARPQuerier(eth0);
arpresponder::ARPResponder(eth0);

ethout::Queue
-> ToDump(out_eth0.pcap,PER_NODE 1)
-> ToSimDevice(eth0);

// All packets received on eth0 are silently
// dropped if they are destined for another location
FromSimDevice(eth0,4096)
-> ToDump(in_eth0.pcap,PER_NODE 1,ENCAP ETHER)
-> cl;

// ARP queries from other nodes go to the ARP responder element
cl[0] -> arpresponder;

// ARP responses go to our ARP query element
cl[1] -&amp;amp;amp;gt; [1]arpquerier;

// All other packets get checked whether they are meant for us
cl[2]
-> Strip(14)
-> CheckIPHeader2
-> MarkIPHeader
-> GetIPAddress(16) // Sets destination IP address annotation
-> forhost;

// Packets for us are pushed outside
forhost[0]
-> [0]output;

// Packets for other folks or broadcast
// packets get sent to output 1
forhost[1]
-> ToDump(discard.pcap,2000,PER_NODE 1,ENCAP IP)
-> [1]output;

// Incoming packets get pushed into the ARP query module
input[0]
-> arpquerier;

// Both the ARP query and response modules send data out to
// the simulated network device, eth0.
arpquerier
-> ToDump(out_arpquery.pcap,PER_NODE 1)
-> ethout;

arpresponder
-> ToDump(out_arprespond.pcap,PER_NODE 1)
-> ethout;

}

lan::LanSimHost(eth0:ip,eth0:eth);

Now that we have a LanSimHost type ready, and instantiated (in the last line indicated above), we perform the final plumbing required to connect our LanSimHost to our kernel tap device:

// Users can do some processing between the two elements
lan[0] -> kernel;
kernel -> lan;
// Packets for others or broadcasts are discarded
lan[1] -> Discard;

This concludes our description of the nsclick-lan-single-interface.click file. Let’s now describe an ns-3 simulation script for our scenario.

Using the Click graph in an ns-3 script

I’ll now describe a simple ns-3 script which makes use of the above described Click graph. Not surprisingly, the script is named nsclick-simple-lan.cc and can be found within src/click/examples/. The simulation scenario is a simple one: two nodes A and B connected via a CSMA channel, with A sending B a stream of packets using a TCP connection. A is Click based, whereas B is a normal ns-3 node.

The first step would be to create the nodes.

NodeContainer csmaNodes;
csmaNodes.Create (2);

Next, we create a CSMA channel.

CsmaHelper csma;
csma.SetChannelAttribute ("DataRate", DataRateValue (DataRate (5000000)));
csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2)));
NetDeviceContainer csmaDevices = csma.Install (csmaNodes);

We then install a normal internet stack on node B.

InternetStackHelper internet;
internet.Install (csmaNodes.Get (1));

And then setup a Click based internet stack on node A. We need to specify the Click script that the particular node is supposed to use, and in the event that we require a Click based node to run a traffic generator on top, we need to specify a routing table element for the node to use. This can be seen by the name “rt” at the end of the nsclick-lan-single-interface.click file.

ClickInternetStackHelper clickinternet;
clickinternet.SetClickFile (csmaNodes.Get (0), "src/click/examples/nsclick-lan-single-interface.click");
clickinternet.SetRoutingTableElement (csmaNodes.Get (0), "rt");
clickinternet.Install (csmaNodes.Get (0));

Now that all the nodes have an internet stack, we assign IPv4 addresses to all the network interfaces.

Ipv4AddressHelper ipv4;
ipv4.SetBase ("172.16.1.0", "255.255.255.0");
ipv4.Assign (csmaDevices);

And then, we setup the traffic generators for talking between node A and node B.

Address LocalAddress (InetSocketAddress (Ipv4Address::GetAny (), 50000));
PacketSinkHelper packetSinkHelper ("ns3::TcpSocketFactory", LocalAddress);
ApplicationContainer recvapp = packetSinkHelper.Install (csmaNodes.Get (1));
recvapp.Start (Seconds (5.0));
recvapp.Stop (Seconds (10.0));
OnOffHelper onOffHelper ("ns3::TcpSocketFactory", Address ());
onOffHelper.SetAttribute ("OnTime", RandomVariableValue (ConstantVariable (1)));
onOffHelper.SetAttribute ("OffTime", RandomVariableValue (ConstantVariable (0)));

ApplicationContainer appcont;
addressValue remoteAddress (InetSocketAddress (Ipv4Address ("172.16.1.2"), 50000));
onOffHelper.SetAttribute ("Remote", remoteAddress);
appcont.Add (onOffHelper.Install (csmaNodes.Get (0)));
appcont.Start (Seconds (5.0));
appcont.Stop (Seconds (10.0));

Lastly, we enable PCAP tracing on all the CSMA NetDevices in the scenario.

csma.EnablePcap ("nsclick-simple-lan", csmaDevices, false);

And to conclude the script, we specify the running time for the simulation to be 20 seconds, and call Simulator::Run(). Don’t forget to call Simulator::Destroy() lest tools like Valgrind start screaming about memory leaks.

Simulator::Stop (Seconds (20.0));
Simulator::Run ();
Simulator::Destroy ();
return 0;

To see the results of running our simulation, execute the below in your terminal from the ns-3-dev top level directory once you’ve built Click as described in the previous article.

$: ./waf --run nsclick-simple-lan

Have a look at the resulting pcap traces (nsclick-simple-lan-0-[0,1].pcap) using wireshark or tcpdump to see what happened through the simulation.

Hope you found this little walkthrough helpful. If you find any bugs with ns-3-click, please don’t hesitate to file a bug report on our bugzilla.

Sahana Community Meetup @ Lisbon

2011-05-31T15:45:00+00:00

Sahana Software Foundation had its Annual Meeting, Community Bar Camp and a Disaster Workshop at ISCRAM, in Lisbon from the 6th-8th this month. The whole event was fun and a great learning experience. Interacting with members of the community only acquainted through IRC and the mailing list was well worth the 24 hour journey from Kanpur to Lisbon. A special thanks to Google and Sahana software foundation for providing support for travel and stay for the meet.

At the Community Bar Camp, We had a couple of productive discussions on interoperability and the functioning of Sahana Software Foundation. Thanks to the face to face time with the other members of the Eden community - I was able to understand the framework a bit better and work out the requirements for a possible Asynchronous processing API in Eden. The activities for the first 2 days were located at a space, generously donated by IBM Portugal, who also provided us with a huge supply of delicious pastries (Yum!), orange juice and coffee. Evenings were spent in long pleasant dinner sessions followed by late night social meetups at the hotel lounge, supplemented with great wine and amazing ideas/thoughts/people. In short it was a great event with some of the most dynamic and vibrant people I have ever met, who were fun to interact and work with. I very eagerly look forward to the next Sahana Software Foundation's annual meeting, hoping to meet the few who couldn't make it this time around.

Sahana Software Foundation's Blog has a finer and a well written account of the entire event (Click here).

I would like to thank the following people/organisations for making my visit possible:

1) Google and SSF for providing support for Travel.
2) Mark Prutsalis for patiently sending me all the documentation required for the visa.
3) To the unknown person who set the end semester exam timetable at IIT Kanpur, leaving me with the exact time to make it to the event.

This blog post has been long over due - Mostly because, I just finished my Masters in Physics (Yay!) and am in the process of kick starting our tiny private limited (More about this later).

Hiredis

2011-05-27T14:50:00+00:00

Hiredis, a minimalistic C client library for the Redis database is now available for Fedora/RHEL. Install it using:

  $ sudo yum install hiredis hiredis-devel

lalithsuresh

2011-05-22T21:44:18+00:00

Since its development, I’ve been seeing a lot of requests for an ns-3-click 101. So with no further ado, here’s the first in a series of tutorials to help you get an idea of how to go about using ns-3-click. In this article, I’ll provide an idea of what ns-3-click is and how to install it .

1. What is ns-3-click?

ns-3-click, or the NS-3 Click Integration, is a feature of the ns-3 tool which allows a user to use a Click Modular Router instance to handle an ns-3 node’s layer 3 functionality. Click is an architecture for designing highly flexible router configurations. Basically, it offers a large number of fine grained packet processing units called “elements”, which can be put connected in various combinations into a Click graph. A Click graph defines a particular configuration for a router. The motivation for bringing Click into ns-3 is simple. Click users get to test their Click graphs in a powerful simulation environment which ns-3 offers, and ns-3 benefits from the large feature set that Click brings with it in the form of elements. In ns-3-click, the design choice was to entirely delegate ns-3′s layer 3 functionality to Click. This means that an ns-3 node running a Click router will now have to use Click’s implementations of ARP, routing tables and so forth.

So before you get started with ns-3-click, I suggest going through [0] and [1]. The first paper should tell you everything you need to know about what Click is, and the second one will inform you about where Click fits into ns-3. The latter will help you understand what ns-3-click can or cannot do for you.

2. Installation

By now, you know what ns-3-click is, and its time to get your hands dirty. The first step is to download and build Click.

$: git clone http://read.cs.ucla.edu/git/click DIR $: cd DIR $: ./configure --enable-nsclick --enable-userlevel

Note: If you require additional modules, enable them as required using the –enable-<module> flag.

Now build Click:

$: make

Once this is complete, we need to build ns-3 and point it to the Click source we’ve just compiled. So let’s proceed to fetch and build ns-3. Note that ns-3-click was merged post ns-3.10, and will be released with ns-3.11. It is currently available in ns-3-dev.

$: hg clone http://code.nsnam.org/ns-3-dev $: cd ns-3-dev $: ./waf configure --with-nsclick=<path-to-click-source> --enable-examples

Once the last command has finished executing, you should see a list of features/modules that have been enabled. At this point, you should see the following line:

NS-3 Click Integration : enabled

Now, let’s build ns-3:

$: ./waf build

If all goes well, ns-3 should now be built successfully. To test whether things went well, try running one of the example scripts.

$: ./waf --run nsclick-simple-lan

This should generate some PCAP traces (nsclick-simple-lan-*.pcap). If you see packets being exchanged in there, then you’re good to go!

This concludes part I of the ns-3-click tutorial. In the next part, I’ll provide a code walk through of a simple example script that uses ns-3-click. If you find any bugs with ns-3-click, please don’t hesitate to file a bug report on our bugzilla.

References

[0] Eddie Kohler, Robert Morris, Benjie Chen, John Jannotti, and M. Frans Kaashoek, “The Click Modular Router”. ACM Transactions on Computer Systems 18(3), August 2000, pages 263-297. (Paper from the MIT-PDOS page)

[1] Lalith Suresh P., Ruben Merz, ”NS-3-Click: Click Modular Router Integration for NS-3”. In Proc. of 3rd International ICST Workshop on NS-3 (WNS3), Barcelona, Spain. March, 2011. paper

lalithsuresh

2011-04-29T20:33:39+00:00

The wait is over, and we hereby announce the students selected for the NS-3 Summer of Code 2011 programme!

Ashwin Narayan with “Click-MAC extensions for ns-3-click”. Mentored by Ruben Merz and myself.
Pankaj Gupta with “LTE-RRC extensions”. Mentored by Giuseppe Piro and Francesco Capozzi.
Atishay Jain with “IPv6 Global Routing”. Mentored by Tom Henderson and Mitch Watrous.

Congratulations to all the students. Hoping to see a lot of good code come out of this effort and most importantly, some long term contributors to the ns-3 project itself.

lalithsuresh

2011-04-27T21:14:21+00:00

Say you’re a Masters student studying distributed systems, and you just completed 3 major project checkpoints, and wrapped up some work with a research project. So what do you do during the Easter break that immediately follows the deadlines? You go on vacation of course!

So I just got back from a wonderful four day holiday split across the dreamy fields of Schwangau and the Bavarian captial, Munich. Schwangau is a must see for anyone who wants to swim in a sea of breathtaking views and experience the European countryside. It is the home to the famous Neuschwanstein castle, which was the main inspiration for Disney’s Sleeping Beauty’s castle. The village of Schwangau itself lies under the protective watch of the Alps, running through the border between Germany and Austria. I stayed with a good friend of mine, and had a wonderful Bavarian Easter with her family, sharing stories of our cultures and lifestyles. On Easter Sunday itself, we went hiking up the Alps, and I’m still surprised that I made it alive at the end of a 3 hour ordeal. After years of not having any physical exercise of any form, this was indeed rather taxing, but I guess all the muscle strain was definitely worth the experience, the views, and most importantly, the satisfaction that followed taking a hard path up a 1.708km high mountain for your first ever hike.

The latter half of the holiday involved a visit to old city of Munich. Culturally rich and with a Bavarian feel all over, it was a fun experience to walk through the city streets. One thing I found particularly funny was that the Maximilianeum building, which houses the Bavarian parliament, had no gates nor security guards on the outside, which is in absolute contrast to equivalent buildings back home in India, which can be aptly labelled mini fortresses. The last day of the visit was reserved for a trip around the Munich marketplace and of course, the one and only Allianz Arena, which I finally got the opportunity to visit as a long time Bayern Munich fan.

As is always the case with my travels, cuisine formed an important component of the visit too. Thanks to Eva’s help, I was able to compile a list of dishes/drinks I had: Apfelstrudel, Neuernberger Rostbratwuerste mit sauerkraut, Kaesspatzen, Leberkaes mit Kartoffelsalat und Spiegelei, Weisswuerst mit Suessem senf, Schweinsbraten mit Kartoffelknoedel, Schweinshaxen, Brezeln, Radler, Weissbier and Weizen. I particularly loved the German variety as far as beers are concerned. Radler from an altitude of 1.708km tastes heavenly by the way.

I would have loved to stay a little longer, but as the saying goes, all good things must come to an end. Now back in Lisbon, I’m finding it a little hard to shake off the vacation mood and get back to my projects, but I think I’ll pull that off sooner or later.

lalithsuresh

2011-04-20T12:00:04+00:00

My friend Marcus recently suggested a good idea to keep track of papers that we read by writing a publicly available review about the work. So here’s the first in a series of such posts.

Title: Adaptive Offloading for Pervasive Computing

Authors: Xiaohui Gu and Klara Nahrstedt (UIUC), Alan Messer, Ira Greenberg, and Dejan Milojicic (HP Labs)

Motivation: Certain applications have high memory requirements, and thus cannot be easily run on resource constrained devices like mobile devices which are an essential component of pervasive computing environments. In lieu of such constraints, the authors propose a scheme wherein the deployment of such applications on mobile devices is made possible by “offloading” objects in the code (the paper assumes an object oriented language like Java or C#) onto a network-nearby device, hereafter referred to as the surrogate. This needs to be achieved by keeping the application completely oblivious to what’s happening underneath.

The problem: when to trigger an offload, and which objects to offload.

Assumptions in the paper: Object oriented languages need to be used. High speed wireless link required.

Summary:

The core of the work involves describing each Java program as a graph of classes called the Application Execution Graph (AEG). Classes are chosen as the basic unit for representing an application because: 1) Classes map directly to interactions in the system, 2) classes allow more precise/fine-grained decision making for the offloading process (while this line isn’t explained clearly, I believe it has to do with the next point) 3) The said interactions are easier to represent with classes than with several thousand Java objects.

The graph of classes is to be partitioned into two chunks, one of which will remain on the device, and will be locally referenced, whereas the remaining chunk will be offloaded onto another device called the surrogate, usually a desktop or some non-resource-constrained device. Objects on the surrogate will be referenced using remote object invocations. This partitioning will be transparent to the application itself. This means that the Java application would be completely oblivious to the physical locations of the objects that it’s dealing with, but the underlying VM will perform this partitioning, and will use local or remote invocations as would be the case. The VM used for the work was HP’s Chai JVM.

The AEG has weights for the nodes, and the edges. Weights are assigned to the nodes based on the access frequency of the class, the memory size of an instance of the class, the current location of the object, and whether the object _has_ to be on the device (device specific classes like a touchscreen reader for instance, which make no sense on the surrogate). The last property is called the IsNative property.

The partitioning of the AEG is performed using a min cut algorithm, using the weights described above as a parameter for deciding the cut itself. Since determining the min-cut of a graph is an NP-Complete problem, the algorithm produces several possible min cut partitions, and maintains a set of such partitions. In run-time, one of these partitions is picked, depending on what is felt to be most optimal, given the particulars of the constraints in that scenario. All classes which have the IsNative property set to true, are bound to the device and will _not_ be offloaded to the surrogate.

The architecture of the proposed solution is decomposed into a form wherein resource constraints are expressed using Fuzzy Logic. The fuzzy values like “low” and “high” depend on the application itself. Each application can have its own rules for the partitioning of the AEG. Depending on the rules and the current status of resource availability (like bandwidth and memory), we can pick the appropriate partition of the AEG that was generated in the step above. The partitioning is performed in a timely manner such that this computation needn’t be performed when an offload has to be initiated, and we already have a partition available when we hit the resource limit.

The solution was evaluated in a real setting (for a change!) and tools like Dia, Biomer and Java Notes was run. I won’t be elaborating much on the evaluation itself, as it is clearly explained in the paper. I don’t consider it very strong, as it does not explore cases where bandwidth was constrained, but it’s still better than some other evaluations out there.

Weaknesses in the work: Surrogates cannot be migrated on the fly, and this restricts how _far_ the mobile client can stray away from the surrogate. Furthermore, hacking the VM to achieve this may impact portability of the code, but this is much better than having to re-write applications.

lalithsuresh

2011-04-10T20:21:49+00:00

The NS-3 Summer of Code programme has received a good deal of interest from students so far, and I’m pretty excited to see what the final set of applications will look like.

Anyhow, hurry up students, the deadline for NSoC is on the 15th of April, 2011 at 19:00 UTC! Visit the NSoC wiki to find information regarding the applying process. Meanwhile, we recommend that you discuss your proposals as much as possible on the ns-developers mailing list and with your potential mentors before you apply to keep your proposal focused and polished.

ragsagar

2011-04-01T15:24:23+00:00

Two months before i lost 10rs from my mobile balance without using it. When i contacted Reliance customer care they told me that “A joke pack has activated in your account by me last month and this is for the second time they are taking money,It is not possible to refund the money now, but they will deactivate it. It is possible to refund the money only within 24hours after activation of the pack.” I told them that i didn’t activate any such packs and told to deactivate it. On this month 25th i again noticed a decrease in balance by 10rs. So i contacted the customer care executive on 25th morning. He told that a joke pack has been subscribed that’s why i lost the money and it is possible to refund the money as no activation has yet taken place.So i told him to refund. As it didn’t got activate after an hour, i contacted the Customer care again. They told me to wait for 24hours. I waited for 24 hours and contacted them again on 26th evening and what they said was the same, to wait for 24hours. Told the same when i called them on 27th. When i called on 28th one CC executive told me that a complaint has been registered and that i have to wait for two days and i will be getting the complaint no as sms. Within two days i got two messages from them one containing the complaint number and the other informing that the offer pack has been deactivated. But the money was still not refunded. So i contacted them on 31st (yesterday), a CC executive told me that i will be surely refunded within 24hours and told me to wait. Today when i called them one guy telling me that my pack is not yet deactivated, i can deactivate it through an sms and it is not possible to refund the money. WTF??????

lalithsuresh

2011-03-30T22:56:12+00:00

Last week’s Barcelona trip was the perfect weekend getaway from a hectic masters programme. After a not-so-enjoyable stint with changing hostels on Thursday, I met my colleagues from UPC, Barcelona for a nice round of drinks and tapas. I left for the Melia Barcelona early next day for WNS3 2011, and I was obviously excited about meeting the rest of the ns-3 developers for the first time. It’s been more than a year of my involvement with the project, and so far it’s been an amazing experience to work with the really awesome people that comprise of the ns-3 community. So meeting the faces behind the names from the mailing list was something I was looking forward to, and I did. A lot of hand shakes and introductions later, we got started with the programme. My talk went pretty well too.

After the talks, we had a pre-meeting for next day’s ns-3 developers meeting in order to decide the agenda, the priorities, and the action items we planned to walk away with (note that beer is part of the schedule ). The day ended with an amazing dinner at a rather classy restaurant in the city.

The developers meeting took place at the CTTC demo center on Saturday and lasted around 7 hours in total including lunch, during which we discussed and planned ahead as far as solving a number of issues was concerned. We also came to a consensus on organising an NS-3 Summer of Code programme, for which I’ll be handling the reigns. All in all, it was an awesome experience to meet these guys, from whom I’ve been learning a lot over the past year.

So in short, life is good.

ForSyDe

2011-03-25T13:18:00+00:00

Formal System Design (ForSyDe) from KTH Royal Institute of Technology, Sweden is now available for Fedora. It is a methodology with the objective to move system design (System on Chip, Hardware and Software systems) to a higher level of abstraction, and to bridge the abstraction gap by transformational design refinement. You can install it using:

  $ sudo yum install ghc-ForSyDe

It is the 100th Haskell package in Fedora.

lalithsuresh

2011-03-20T00:56:36+00:00

Unfortunately, ns-3 wasn’t selected as a mentoring organisation for GSoC 2011. But don’t worry, it doesn’t end with that. We are keen on self organising a summer of code programme of our own, so that we can support some student projects and offer mentoring for the same over the summer. While we haven’t decided on the exact plan yet, it is on our agenda for next week’s ns-3 developers’ meeting at Barcelona, co-located with Simutools 2011 and WNS3 2011. So stay tuned for updates from our end. If you have any ideas, suggestions or expectations from such a programme, feel free to get in touch with me and let me know what you think.

Reading raw disks with python - Windows/Linux/Mac

2011-03-01T13:09:00+00:00

We have been working for a while on an embedded solution that geo-tags jerks using an accelerometer (I know it sounds funny :)). Not wanting to increase the overhead on our tiny < 16MHz 8 bit AVR and maintain our precise sampling requirements, we came up with a simple filesystem that does the job and this fancy format meant that we needed some code on the computer end to read the sdcard. Took us a while to search out the raw disk file for Windows. The following snippet shows how to search the disk at a particular address - [Our disk structure had the word MOMS at that address.]

tl;dr Snippet to read the raw disk using python on Windows/Linux/MacOSX

lalithsuresh

2011-02-23T18:45:02+00:00

As the title suggests, ns-3-click is finally in. So go ahead, clone ns-3-dev, and test all your Click graphs today! And as always, patches and improvements are welcome.

EFY Expo 2011, New Delhi

2011-02-22T15:30:00+00:00

I had participated in the panel discussion on "Free/Open Source Hardware - What it means to Design Engineers" at the Electronics For You Expo 2011, Pragati Maidan, New Delhi on Saturday, February 19, 2011 representing Fedora, and Fedora Electronic Lab. Massimo Banzi (Arduino) chaired the session.

The presentation and photos are available. It was good to meet up with Massimo Banzi, Marcus Erlandsson (OpenCores.org) and Kyle Wiens (iFixit). Marcus Erlandsson gave a demo of the ORSoC development board:

I was also able to catch up with few Arduino hackers from Delhi. We had a good discussion about open hardware, licensing, community development, hardware hacking, and of course Fedora Electronic Lab. Special thanks to Electronics For You for sponsoring the travel.

parameterized-data

2011-02-21T06:10:00+00:00

parameterized-data is now available for Fedora. Install it using:

  $ sudo yum install ghc-parameterized-data

A tutorial illustrating vectors parameterized in size using the above is written by Alfonso Acosta.