Categories
nemo

Nemo 0.2.4 released

Nemo is not quite dead yet. It’s been a long time since the last release, as I’ve been super busy with external contracting work at IOLA so I havn’t really had time to work that much on Nemo. There are some interesting things coming up in the Nemo space in the future, so far I can’t say much about what they are since they are still quite a bit up in the air, but be sure that Nemo is not dead yet 🙂

Categories
nemo

Attending the Maemo Summit 08 in Berlin 19-21 Sept.

I’ve just booked tickets and will be attending the Maemo Summit. I’ll be there for mostly for the Desktop Search Hackfest representing Nemo.

Categories
nemo

Release time! Nemo 0.2.3 released

Had some nice crasher fixes in svn for a while so I thought I would do a release of Nemo. The release is very minor, but the changes should be rather welcome for everyone 🙂

Categories
iola nemo

Nemo 0.2.2 released

I made a new release of Nemo 0.2.2 today. It has some nice memory usage improvements and indexing fixes. Plus day view got pagination so that it can handle large number of files on a single day (like an svn update) gracefully. Upgrading is highly recommended.

Categories
.net c# nemo Programming

Improving latency while keeping your sanity

We had this problem in Nemo 0.2.0 that it would use quite a lot of cpu while it was indexing. I kind of knew this could happen but hoped that a transaction optimization to the database could improve the performance enough to make this problem irrelevant. Sadly it did not. The indexing code works by running an event loop in a single thread and then having two queues, one for tasks that needs to be completed fast and one for background tasks. Each of the queues are basically just a list of function pointers that is popped when a new task need to run.

The nice property of the indexing code is that it would put each task into simple function that one could read from start to end. The same property that is usually associated with programming using threads compared to programming using events where the code has to be broken into several parts. I feared that I had to go the event way and break the indexing up into smaller functions and do a lot of tedious book keeping to make sure the code could be resumed.

After thinking about the problem for a little while it dawned on me that this is the a perfect case for yielding. Yielding allows you to suspend the execution of a function and return immediately which is perfect for this problem since the runtime will automatically do all the book keeping for you. Another really nice thing is that it turns out that converting the code was extremely simple.

Instead of storing simple function pointer in the queue, we just store an object of type IEnumerable<bool> which will wrap the function and make sure we can call it multiple times. When the Enumerable is called it will keep returning true as long as there’s still work to do in the function wrapped. So the function could just return false and it would work the exact same way as it did before. So one can think of the IEnumerable as a sort of higher order function.

So we just need to wrap the normal functions with the following code:

private IEnumerator TurnEnumerableIntoEnumerator(IEnumerable enumerable)
{
	IEnumerator < bool > t = enumerable.GetEnumerator();

	while (t.MoveNext()) {
		yield return t.Current;
	}

	// make compiler happy
	yield break;
}

And make the function wrapped return IEnumerable instead of void. Then the function can at any point in the function do a simple yield return true; to signal that the function can be resumed to complete its task. So this way it is also very dynamic since a function can return if it has done X amount of work, or if X amount of time has passed or if it is signalled by some other code that a low latency task has been added to the queue. It really adds a lot of flexibility while still keeping the nice structure of a simple function. The complete code is in nemo 0.2.1 under metadata/MetadataStore.cs.

Categories
iola nemo Programming

Nemo 0.2.1 released

Did the release of nemo 0.2.1 today. The release is the result of a large amount of massaging of the nemo code to use less cpu and memory (a garbage collector suddently makes these interlinked in a new one is not usually familiar with when coming from a language like C++). Then some profiling and massaging of GTK# which is sadly still not 100% ready for prime time. And finally some poking at mono code for which I’m not ready with a patch yet (tomorrow it will be), but I’ve improved the performance of the inotify backend of the filesystemwatcher by quite a bit especially when watching a large number of directories.

Categories
iola nemo

Nemo 0.2.0 released

Long time since I’ve blogged about Nemo. Since the initial release a little over a month ago we have had two major releases, the first one a bugfix release to fix some of the defects reported and the 0.2 release which adds support for beagle through Xesam and lots of other nice enhancements like pagination on the search results popup and better indexing performance. The software is still fresh but I consider this to be the first release that I would feel comfortable recommending to a stranger 🙂

Categories
iola nemo

Announce Nemo 0.1

I’m very pleased that I can now finally lift the curtain and show what I’ve been spending most of my time working at iola on.

It’s been a long ride, but now the alpha release is finally ready for public consumption 🙂