Monday, August 29, 2016

OSX El Capitan hangs or freezes during boot or after login acutally

I twice had the case that after upgrading and after an update, my MacBook Pro froze doring / after the login screen.

What didn't help - but what's always worth a try:
  • Deleting the NVRAM (Cmd + P + R + Pwr)
  • Booting in safe mode (shift + Pwr)
So what was the Problem? Kernel Extensions!  How to fix it?
  • Boot into recovery mode (Cmd + R+ Pwr)
  • If you have FileVault enabled, open the Disk Utilities, select your main drive (which is grayed out) and select "Unlock..." in the Menu
  • Start a terminal
  • Remount everything writeable: mount -rw /
  • Naviagte to your Kernel Extensions folder: cd /Volumes/System/Library/Extensions
  • Look for new or non-standard extensions and move them in a subdirectory called "Unsupported: mkdir Unsupported; mv Stuff.kext Unsupported/
  • The list of standard extensions can be found here: ls /Library/Extensions
  • Good candidates in my case were Logitech Drivers and or a USB to Serial driver
  • Reboot
An excellent writeup of all this can be found here: https://www.justinsilver.com/technology/os-x-el-capitan-10-11-1-hanging-on-boot-fixed/
Note however, that in this tutorial, the step of unlocking FileVault is missing, which is essential when using an encrypted harddisk.

Monday, April 11, 2016

Using the Raspberry Pi to program a Microchip PIC (PIC24) device via ICSP

Why would someone want to do that? Well, basically for two reasons. First, the classic: "this should be possible" - so lets try it, spend the better part of three weekends and some nights to finally get it working. Might sound stupid, but to me, this is still the best way to really learn a technology or technical topic. Starting with basic C++ skills, I learned a lot about PIC assembler (yep, ICSP for PICs is basically sending a bunch of op codes to the device), PIC memory layout and of course PIC ICSP and controlling GPIOs of the Raspberry Pi.

What's the second reason? In my case, I have a PIC connected to the Pi anyway, talking to each other via RS232 - so I figured I could use the spare pins on the connector to assign some GPIOs to the appropriate PINs on the PIC and I don't need a second connector for ICSP, the board is quite full anyway. Also I can update the firmware without having to build a bootloader (which is a topic on its own).

I case you're curious, the whole project will eventually be a driver board for my 3 axis CNC. Currently I have a PC + Arduino + GBRL-Shield, but I'm not happy with the setup. So I'm planning on building a web based controller on the Pi. This way I can control the machine using a cheap Galaxy Tab A or my mobile Phone. Also I can directly upload the G-Code (produced by Fusion 360 - AWESOME!) from my laptop - either directly or via my NAS or Dropbox or the like (both machines are quite a bit apart).

OMG Andy, all this has already been built?! Yes - it is still fun to try it yourself and learn a whole lot new :-)

Because I found a lot of inspiration and help in the projects of others, I tried and document my code quite well a bit. Also I added a bit of a description on how it all works - so if you're into ICSP / PICs / GPIOs have a look here: OpenCobra on GitHub

Saturday, February 6, 2016

C code always runs way faster than Java, right? Wrong!

So we all know the prejudice that Java being interpreted is slow and that C being compiled and optimized runs very fast. Well as you might know, the picture is quite different.

TL;DR Java is faster for constellations, where the JIT can perform inlining as all methods/functions are visible whereas the C compiler cannot perform optimizations accross compilation units (think of libraries etc.).

A C compiler takes the C code as input, compiles and optimizes it and generates machine code for a specific CPU or architecture to be executed. This leads to an executable which can be directly run on the given machine without further steps. Java on the other hand, has an intermediate step: Bytecode. So the Java compiler takes Java code as input and generates bytecode, which is basically machine code for an abstract machine. Now for each (popular) CPU architecture there is a Java Virual Machine, which simulates this abstract machine and executes (interprets) the generated bytecode. And this is as slow as it sounds. But on the other hand, bytecode is quite portable, as the same output will run on all platforms - hence the slogan "Write once, run everywhere".

Now with the approach described above it would be rather "write once, wait everywhere" as the interpreter would be quite slow. So what a modern JVM does is just in time compilation. This means the JVM internally translates the bytecode into machine code for the CPU at hands. But as this process is quite complex, the Hotspot JVM (the one most commonly used) only does this for code fragments which are executed often enough (hence the name Hotspot). Next to being faster at startup (interpreter starts right away, JIT compiler kicks in as needed) this has another benefit: The hotspot JIT known already what part of the code is called frequently and what not - so it might use that while optimizing the output - and this is where our example comes into play.

Now before having a look at my tiny, totally made up example, let me note, that Java has a lot of features like dynamic dispatching (calling a method on an interface) which also comes with runtime overhead. So Java code is probably easier to write but will still generally be slower than C code. However, when it comes to pure number crunching, like in my example below, there are interesting things to discover.

So without further talk, here is the example C code:

test.c:

int compute(int i);

int test(int i);
 

int main(int argc, char** argv) {
    int sum = 0;
    for(int l = 0; l < 1000; l++) {
        int i = 0;
        while(i < 2000000) {
            if (test(i))
            sum += compute(i);
            i++;
        }   
    }
    return sum;
}

test1.c:

int compute(int i) {
    return i + 1;
}

int test(int i) {
    return i % 3;
}


Now what the main function actually computes isn't important at all. The point is that it calls two functions (test and compute) very often and that those functions are in anther compilation unit (test1.c). Now lets compile and run the program:

> gcc -O2 -c test1.c
> gcc -O2 -c test.c
> gcc test.o test1.o
> time ./a.out

real    0m6.693s
user    0m6.674s
sys    0m0.012s


So this takes about 6.6 seconds to perform the computation. Now let's have a look at the Java program:

Test.java:

public class Test {

    private static int test(int i) {
        return i % 3;    }

    private static int compute(int i) {
        return i + 1;    }

    private static int exec() {
        int sum = 0; 
        for (int l = 0; l < 1000; l++) {
            int i = 0; 
            while (i < 2000000) {
                if (test(i) != 0) {
                    sum += compute(i); 
                }
                i++; 
            }
        }
        return sum; 
    }

    public static void main(String[] args) {
        System.out.println(exec());     
    }
} 
 
Now lets compile and execute this:

> javac Test.java
> time java Test

real    0m3.411s
user    0m3.395s
sys     0m0.030s


So taking 3.4 seconds, Java is quite faster for this simple task (and this even includes the slow startup of the JVM). The question is why? And the answer of course is, that the JIT can perform code optimizations that the C compiler can't. In our case it is function inlining. As we defined our two tiny functions in their own compilation unit, the comiler cannot inline those when compiling test.c - on the other hand, the JIT has all methods at hand and can perform aggressive inlining and hence the compiled code is way faster. 

So is that a totally exotic and made-up example which never occurs in real life? Yes and no. Of course it is an extreme case but think about all the libraries you include in your code. All those methods cannot be considered for optimization in C whereas in Java it does not matter from where the byte code comes. As it is all present in the running JVM, the JIT can optimize at its heart content. Of course there is a dirty trick in C to lower this pain: Marcos. This is, in my eyes, one of the mayor reasons, why so many libraries in C still use macros instead of proper functions - with all the problems and headache that comes with them.

Now before the flamewars start: Both of these languages have their strenghs and weaknesses and both have there place in the world of software engineering. This post was only written to open your eyes to the magic and wonders that a modern JVM makes happen each and every day.