At ProFUSION a common topic is how to optimze the system. Not just the speed, but also what and how it is done. Not just for our embedded systems, but also our desktops and laptops.

These discussions led us to be involved in projects that consider this goal, such as Enlightenment, ConnMan, oFono and systemd. With great projects, come great people and thus enlightening discussions on how to improve things. From these discussions Lennart Poettering and Kay Sievers put together a A Plumber’s Wish List for Linux, with one of the items being of special interest for ProFUSION as it had the potential of also helping embedded systems and speeding up or boots:

* module-init-tools: provide a proper libmodprobe.so from
module-init-tools:
Early boot tools, installers, driver install disks want to
access information about available modules to optimize
bootup handling.

One of the reasons for this is that udev will search /sys/devices for all “modalias” files and call “/sbin/modprobe -bv $ALIAS“, however many of these calls evaluate to an empty list, thus an useless execution of program that will open /lib/modules/`uname -r`/modules.*, load resources, search for something that is not there and return. This could be way cheaper if done inside udev workers. [note: Lucas did measure and noticed 2.5x speedups, stay tuned for benchmarks]

kmod

Then our developer Lucas De Marchi proposed to do the libmodprobe and we funded it. After some discussions with Lennart and Kay, it was decided to rename it to kmod for shortness and good namespace. The initial goal was to achive a 1:1 replacement of module-init-tools as a library to be used by udev and systemd-modules-load and we are close to it with our second release done today! While we miss depmod tool (planned for v3), our kmod-modprobe should be fully functional and if this proves to be true, the logic will move to libkmod to be used by udev.

we need your testing!

To ensure kmod-modprobe does what it is supposed to do, we need extensive testing, there is where we need you! Try it on as many systems as possibles and let us know. To do this we recommend:

$ git clone git://git.profusion.mobi/kmod.git
$ cd kmod
$ ./autogen.sh
$ ./configure --enable-logging \
              --enable-debug --enable-tools \
              --enable-zlib # if you have module.ko.gz
$ make all
$ sudo make install
$ sudo mv /sbin/modprobe /sbin/modprobe-bkp
$ sudo ln -s /usr/bin/kmod-modprobe /sbin/modprobe
$ ls -1 /sys/module/ > ~/original-modules
$ reboot
$ ls -1 /sys/module/ > ~/kmod-modules
$ diff ~/original-modules ~/kmod-modules

current users and feedback

Being a new project in a critical area of Linux system, we expected lots of criticism and rejection by people, but interestingly enough after Lucas’ announcement and LWN article the feedback was highly positive! We even had some testers and people to help with ideas and experience.

Among the people that joined the project is the current maintainer of module-init-tools package Jon Masters, which announced that kmod replaces module-init-tools. He is helping a lot with his knowledge and cases from Red Hat Enterprise Linux, also providing modules from non-trivial platforms such as s390. Last but not least he provided insights to improve module handling on Linux, particularly replacing modules with better alternative as required in enterprise systems.

With Jon’s blessing we’ll use the same mailing list linux-modules@vger.kernel.org and our git will move to kernel.org soon.

People from ARCH and Debian were also interested and even created packages for it! These guys were extremely helpful to test cases such as gzip modules, 64bits modules with i386 user space and so on. They are: Tom Gundersen (tomegun), Dave Reisner (falconindy) and Marco d’Itri (Md).

next steps

Based on our TODO, we have the following ideas for next steps:

• Finish libkmod-elf.c to provide information required by depmod. I’m working on this in my depmod branch;
• tools/kmod-depmod.c: create a 1:1 compatible tool to generate /lib/modules/`uname -r`/modules.*;
• libkmod should export parsed configuration to be used by kmod-modprobe.c –dumpconfig;
• create kmodmock library to be LD_PRELOAD’ed to redirect some syscalls such as init_module(), delete_module() and open() of /sys and /proc. I’ve started a branch for this some time ago as “unittest” branch but stopped due lack of ELF support at the time;
• create unittests and measure coverage. Given kernel modules are user-input they may be broken files and libkmod-elf.c needs to be extensively tested to avoid segmentation fault due out-of-boundaries access. This mean not trusting null terminated string in .strtab section and so on.
• create optimized modules.archive that would contain optimized search index and all modules compressed independently, but in the same file. This would save file access and could provide information we don’t have today, like the uncompressed size of gzipped modules.

All in all the event was great, not just due the talks but mostly due the friends and side-talks. Being at these events for a few years I managed to know lots of people from different projects. Not being in a major side (read: KDE or GNOME) I have the gift of free-transit among these fields… which is pleasant as I can gather ideas from both. [There is no hard or official barriers between them, but the psychological blocks peers from talking to each other and this is quite bad]

I came there sponsored by my company (ProFUSION embedded systems) to represent the system that provides a big bucket of our consulting, training and development services: Enlightenment.  I had the pleasure to engage into endless conversations with Enlightenment developers and community leaders (Cedric, Boris, Michael, Philippe…) We discussed a lot how we could broader EFL usage, bring more users, lower the barrier to new developers with easier to use tools and languages and of course how we could get Raster to release E17.

I also tried to learn from other people of technologies as well.  Before I was an Enlightenment hacker I did use and develop with Qt/KDE and already knew some icons such as Aaron Seigo, Thiago Macieira, Helio Castro and Sebastian Kügler, which I managed to meet again. Of course my ex-coworkers at INdT and KDE fanatics Artur Duque de Souza, Renato Chencarek were there. And I was introduced to Daker Fernandes Pinheiro, from INdT. We discussed QML, Qt, MeeGo and lots of optimization and API designs. Quite productive!

Being part of Maemo since 2006, attended some GUADEC and hacked Gtk/GNOME for fun and work I got to know some icons there as well. I’ve talked to Lennart Poettering, Marcel Holtmann and Marc-André Lueau, people that I’ve worked together in a way or another and that are always open minded to discussions. I’ve also touched base with some people like Lucas Rocha and Zeeshan Ali. It is interesting to know what these guys are doing for Linux Desktop (and mobile) infrastructure and their vision for GNOME.

My presentation went quite well, I was bit anxious and nervous in such a huge room that held it, but I guess people understood the history of Enlightenment, why we created the “Foundation Libraries” (instead of using Gtk or Qt),  our special care with performance and why it will always pay off. I did some heavy critics to FreeDesktop.Org that generated positive feedback from Thiago Macieira (Qt/KDE) and people from other desktops (XFCE/LXDE). Last but not least I’ve made it clear Enlightenment has serious problems to manage community, we’re quite bully, and did thank the guys like Philippe Caseiro and other french dudes that are trying to solve this issue.

All in all a great event, with great people! Looking forward to be in next desktopsummit as well!

While 0.4.4 is no big leap ahead of 0.4.3 I’m doing this post more to make clear people that the project is still alive and it may be the right tool for you, particularly if you need fast media scanning on your desktop or embedded device.

Introduction (History)

LightMediaScanner (LMS) was born in 2007 during the development of Canola2 media player for Nokia N800 Maemo device. We did a previous try at media scanners for Canola1 and did learn a lot, that would be the foundation of LMS.

We had two major problems to solve:

1. scan large amounts of media as fast as possible
2. don’t mess with interactivity.

The first problem had more qualifiers, like the media being unreliable (broken files), be removed without prior notification (mmc removed when system was off), slow discs (sd/mmc), small amount of available RAM, low-end CPU and so on.

Traditional approaches were slow and would bring your device to unusable state for minutes, even after the scan process finished as they consumed too much memory that would swap your applications and services. They would also be naive with file scanning and would trash filesystem’s cache with useless data.

Existing Solutions Problems

At that time we had Maemo’s media scanner that was awful and Tracker was being developed to solve its problems. However Tracker was immature and had other focus, more like being fancy with new standards and trying to solve all the diseases of the world… while we need to be fast in some specific cases.

To highlight technical problems, let’s consider JPEG scanners. Everything one Media Player application would need is the  title, author/artist, date, width, height, orientation and maybe geolocation. These are few bytes, particularly because Title and Author are missing in most cases. We should open the file, get these bytes, register these and close the file. Every system at the time used libexif to do so, however it would copy all the header to memory prior to scanning. Given that most files contain thumbnails in the header, it would mean useless malloc + read of around 10-50kb, to get dozen bytes and exit. This trashes the VM and disc. Moreover, some libraries would open the file themselves and would not fadvise as POSIX_FADV_DONTNEED, thus the filesystem would keep it in cache for further access that never happen! Similar situations existed for PNG, Mp3 and others.

LightMediaScanner Solution

We decided to go with a 2 process solution to avoid crashes and hang-ups on the main process. This would be safe and we could kill the slave process if it took too long to report on a given file. Later on we introduced threaded and single process scanning that would be useful in some cases.

We also had dynamic loadable plugins (shared objects) with the media parsers to be used given matching extensions. The plugins can be selected by the user at runtime. Yes, we would not scan every file with every parser, we did trust the extension as a way to save work and it worked fine, and fast.

The main process just scans the filesystem and  pipes the files to the slave (thread or process). This slave would open the file, get the data to populate a structure to be written to database, then close the file and report back the progress. If the slave takes too long to reply or dies, it’s respawned with the next file in the queue.

The database uses SQLite3 and a configurable number of files are processed in one SQL transaction, thus we’d not hit the filesystem with writes that often. The database access is provided with helper functions that uses pre-compiled statements. However we only provide the insert/update methods, as the fetch (select) are up to the application to use (maybe using their own ORM framework).

Some metadata formats did not specify encoding (ASCII was assumed) and fallbacks can be applied with the charsets. It will use iconv in a priority list to figure out what works.

Just the Indexer!

LightMediaScanner is not a daemon-service, it does not talk DBus neither requires you to speak  RDF or SPARQL. If you want, you can create one with it, but it does not provide this stuff out of the box. Basically you call it to check for media and then access the database yourself, using the SQLite3 directly or using some ORM, doing caches or not, it’s up to you.

The database tables are quite simple and try to provide common useful relations. It’s not designed to cover all weird cases in the world (like multiple artists per song or which lens did you use with your camera).

Using it!

Get the code from our GIT or use the release tarball, see http://people.profusion.mobi/cgit.cgi/lightmediascanner.git/. It uses standard autoconf/automake to build, so should be familiar to most developers.

It hard-depends only on SQLite3 and iconv (most libC ships with it). Optional dependencies are libvorbis, libmp4v2 and libflac.

You can call the scanner from C, C++ or Python using our bindings. Comprehensive example can be found at src/bin/test.c

References: previous post about lightmediascanner 0.2.0 release

After I started on twitter and facebook the blog posts reduced a lot… anyways I’d like to mention I’ll attend DesktopSummit 2011 in Berlin to represent the Enlightenment (aka E17) team and thus an alternative view to the traditional GNOME x KDE.

Fortunately I have couple of friends in both GNOME and KDE so I can express our E17 voice without being ignored (at least immediately ;-P). Dunno if it’s me or E17 being the underdog, but people don’t feel afraid to listen to our ideas and they even try to incorporate those that make sense, like Enlightenment’s Edje that resulted in QEdje that in turn resulted into QML that boosts Qt development these days.

My focus will be:

• performance matters: even if you have a fast hardware today and an even faster hardware tomorrow, you should care about performance. I’m not talking about neat picking premature optimizations, but to design platforms and standards considering performance. It’s often not harder, just need to be considered from the beginning. What bugs us most is the stupid freedesktop.org thumbnail standard, that forces use of PNG even if most of our pictures are in JPEG, causing slower thumbnailing time, bigger disk footprint and slower load times. Second in the list is the traditional abuse of XML, praised years ago and suddenly GNOME realized it was a bad idea (given GSetting/DConf), but it’s deeply inside our desktops with fontconfig and others (want faster application load times? Don’t use XML.);
• Broader Standards: A standard must be thought outside the “I’m implementing it for myself” scope. Similar to above, we should consider broader standards and not get a piece of GNOME or KDE and say it’s a standard. Freedesktop.org fails to get standards because of this stupid approach. See the last flamewars around simple topics as the systray replacement. Actually the systray standard is a well known bad example, people wrote it like if GNOME was the only way to do this. Enlightenment officially ignored this standard due stupid bugs with XEmbed specification and approach (as EFL uses the “windowless widgets” for a while, the XEmbed made no sense and caused user experience problems);
• Embedded is the future. Okay, it will be a DesktopSummit, but as Rasterman predicted  in 2002 the desktop game is unlike to be changed from Microsoft dominance and we better look for new fields where we can compete equally. Given Android, WebOS, Maemo, MeeGo and others, it’s clear that Linux does dominated the mobile world. With appliances (from TVs to DVR to Refrigerators) being dominated for a while (after the embedded cpus got more powerful, most embedded OS got replaced with Linux). Thus together with performance we must not restrict ourselves to the keyboard-mouse-X11-big-screens approach that we used before. This is not just about scalable (as in multiplication) GUI as people believed SVG would help, but we need different GUI for different environments and our toolkits and infrastructure have to help with that… something that Apple is currently doing quite well with their iOS UI toolkit providing universal applications that run optimized on both iPad and iPhone/iPod.

If you’re also attending this summit, let’s meet there and have some beers.

“There is no better tool to debug than printf()”
– Latin proverb from an old Chinese man.

That’s what every programmer knows. Despite interesting tools like profilers, debuggers and other tracing tool, for a reason or another we often resort to good old printf(). The logic behind this is quite simple: it’s available everywhere and have no impact on performace (mostly, on both cases — don’t be picky!), yet it allows you to check out if your program flow is as you expected and if not, what’s happening. The bad part, of course, is that it’s invasive and cumbersome to type, often introduces errors by itself (come on, raise your hand if you never ever wasted hours debugging to notice that the bug was in the debug message!)

GDB and some tools like ltrace or GLibC’s latrace are not always available, particularly on embededd systems they may be available but almost unusable. I hit that in the past weeks during some debugging on an old MIPS where I had to investigate why my supposedly correct program did not work, but a proprietary one did. Documentation is almost inexistent and makes you more clueless than not, thus I had to compare what we were doing differently.

At first I started doing an old trick to create a shared library to be $LD_PRELOADed on my own that would log what was being called, then dlopen()/dlsym() the actual symbol, call it, then log again, then return. I did it for a handful functions, some I even printed out structure members and although it worked, soon I got bored and hit by the laziness that most programmers have: I must make this automatic. Liblogger was born.

Liblogger is Python program that will parse a C header file and generate a source file that does exactly what I described above: log entrance, call the actual function and keep its return value, then log exit, then return the value. That’s the basics this single-file without external dependencies do. This source file can then be compiled into a shared object or into the final application.

Of course I wanted it to be as helpful as possible, so this first version already includes some nifty features:

• source file can be compile-time configured using CPP defines to produce colored, thread-safe, timestamped (gettimeofday, clock_gettime), indented (nesting level) output. This output can go to stderr or some given file;
• generates makefile for you, creating most of aforementioned variations by default. Just pick the one you want to use and LD_PRELOAD it;
• generate types file with all parsed enums, structs, unions and typedefs;
• generate formatters file with custom functions to print out known enums, structs and unions. No more copy + sed on the original structs to produce printf() statements manually!
• will keep errno intact so functions that rely on it will work as it will not be reset by fprintf() calls;
• can be compiled in a thread-safe way, doing locks around dlopen(), dlsym() and the log FILE* to keep messages atomic. It will also keep the indentation level per-thread and print out thread ids (if not main thread);
• Behavior is completely controlled with a INI-style configuration file. It can (check for more at README.txt):
  • tell the parser tokens to ignore;
  • filter (positively/negatively) functions to log;
  • specify type formatters you want to use. Couple are provided for basic C types, and you can request it to generate custom formatters for parsed types as mentioned above;
  • specify return value checkers you want to use. Couple are provided, including one that checks for errno and logs the value as a string;
  • if types of parameters and return are safe to be used by formatters, this can be used at various levels to provide black-white lists for these and keep it useful and safe;
  • special handling of return (output) parameters, their values can be dereferenced and printed out after the actual function is called;

Usage should be pretty straightforward but I distribute two examples, one for dbus and another for jpeglib. Part of the dbus example is reproduced below:

• dbus.cfg

[global]
headers = dbus/dbus.h
overrides = formatters-%(header_name)s.c
# regular expression for all defines in dbus-macros.h
ignore-tokens-regexp = (DBUS_MACROS_H|DBUS_BEGIN_DECLS|DBUS_END_DECLS|DBUS_BEGIN_DECLS|DBUS_END_DECLS|DBUS_DEPRECATED|DBUS_DEPRECATED|DBUS_DEPRECATED|DBUS_EXPORT|DBUS_EXPORT|DBUS_EXPORT|DBUS_EXPORT)

[type-formatters]
DBusHandleMessageFunction = %(prefix)s_log_fmt_pointer
DBusFreeFunction = %(prefix)s_log_fmt_pointer
DBusHandleMessageFunction = %(prefix)s_log_fmt_pointer

[safe-formatters]
DBusHandleMessageFunction = true
DBusFreeFunction = true
DBusHandleMessageFunction = true

# be pedantic about safety, let's specify all strings independently

[func-dbus_message_new_method_call]
parameter-bus_name-safe = true
parameter-path-safe = true
parameter-interface-safe = true
parameter-method-safe = true

• call:

  liblogger.py \
      --config dbus.cfg \
      --makefile Makefile.dbus-connection \
      --makefile-cflags "\`pkg-config --cflags dbus-1\` -I." \
      --custom-formatters formatters-connection.c \
      /usr/include/dbus-1.0/dbus/dbus-connection.h \
      libdbus-1.so \
      log-dbus-connection.c
  make -f Makefile.dbus-connection
  LD_PRELOAD=./log-dbus-connection-color-timestamp.so d-feet
  

First, as said before MeeGo is not just about Nokia or phones, it’s also being pushed as In-Vehicle Infotainment (IVI) and is already adopted by BMW, which you can see daily contributions on projects such as ConnMan. So let’s not assume it is the end of the world given Nokia’s action.

Second, although Android and WebOS are indeed Linux since they use this kernel, we often want more traditional user-space stack, like MeeGo would be. For those,  don’t loose hope! Today (Feb14, 2011) we got a major announcement at MWC by LiMo: LiMo Foundation Unveils LiMo 4. It’s based on X11, WebKit, GNOME and… EFL!

Wait? Where do you see EFL in that announcement? You’ll have to check What is the LiMo 4 Platform? block diagram and see EFL is now a first class component at it, together with GNOME that was there since first release. Yeah, we surely could use better publicity at EFL side

The release is still just text and no code, which should be available by July2011, however you can get code straight from EFL SVN.

ProFUSION team is happy due our contributions to make this possible, after all we help with EFL and WebKit-EFL developments!

This module follows my previous ConnMan module and is built upon the same base. Since BlueZ and ConnMan are both developed by almost the same developer group, the DBus APIs are very similar. The current module is quite simple, yet useful and allows pairing devices. The idea is to further extend it to be a full Bluetooth Agent, allowing different authentication and authorization methods, maybe go even further and send files using the OBEX protocol.

The infrastructure is available as ebluez inside e_dbus, so it is easily accessible to all EFL applications. The infrastructure exposes just a handful methods that were required by the module, but it is easily extensible as most methods are similar and the helpers do most of work, just need to specify the method names and convert types.

ProFUSION is also working on oFono support. Stay tuned to see the module João Paulo is cooking, the e_dbus code is already in SVN.

• Ardy, a tool that brings together EFL and Arduino using Python
• Free.fr, the second biggest ISP in France opened up the development of their Freebox HD set-top box using Enlightenment Foundation Libraries and Mozilla JavaScript library. This is pretty amazing as it’s the biggest deployment of EFL out there, an uncertain number that ranges from 2 to 3 million devices.

Yesterday we started to see some announcements of companies backing Enlightenment Foundation Libraries development. Of course, INdT was pioneer in that since it was decided to use it for Canola2. Later on I created my own company and we officially support EFL as GUI alternative (together with Clutter, GTK and Qt), being the first company to do that.

While there are speculations about which company is it, what I can assure you is that this company is serious and is not alone. ProFUSION itself worked on EFL on behalf of various clients and you may expect another press release about a big French internet and telecom company deploying a massive number of units with EFL pre-installed. Not accounting various community driven projects that choose it and E17 as its base platform, such as OpenMoko and OpenInkpot.

Bottom line? While EFL does not get the same amount of marketing and visibility as Qt and GTK counterparts, it is playing fine enough to be considered to ship in dozen million devices in the next year. Why don’t you consider it for your project? Be open minded and try it out

As usual he wrote a fast software engine to make this available on non-3d accelerated, next should come OpenGL and OpenGL-ES as some big players in the industry are now funding his work in both software and GL-ES support, as well as ARM NEON optimizations.

As ProFUSION is also being funded to work on WebKit-EFL, I thought I could demo our work using new rotation support, and the result is quite good:

As you can see, there are still bugs… actually this video was first meant to report a bug with mapping code, but raster is already fixing it.

As soon as I have time I’ll try to update EFL for N900 and try out the new expedite tests, they include 3d cubes, coverflow and more. Hopefully by the time OpenGL-ES will be ready and then we can compare software and hardware performance on this amazing hardware.

All in all, this semester is being quite busy for EFL hackers. Fast OpenGL-ES, UV Mapping, WebKit and soon-to-be-release Edje Editor were all done, with much more to come. Stay tuned!