guess what...

All about Miguel Luis moralities. Read more: http://goo.gl/2oPAh

[mluis]

Share XQuartz with Docker

On one terminal run: $ ip=<your interface ip>

$ xhost + $ip

$ socat TCP-LISTEN:6000,reuseaddr,fork UNIX-CLIENT:\"$DISPLAY\"

On another terminal run your container like:

$ ip=<your interface ip>

$ docker run --privileged --rm -it -e DISPLAY=$ip:0 -v /tmp/.X11-unix:/tmp/.X11-unix:rw --net=host --ipc=host --name redected ubuntu bash

[mluis]

When taking a bullet on the butt was kinda fun. =P

[mluis]

Ping!

...

[mluis]

Headless RPi Zero

 - Mount the SD card and edit: etc/network/interfaces with:

auto wlan0 allow-hotplug wlan0 iface wlan0 inet dhcp    wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

 - Then edit: etc/wpa_supplicant/wpa_supplicant.conf with the network configuration of choice. eg.:

# WPA-PSK/TKIP network={     ssid="NOON"     key_mgmt=WPA-PSK     proto=WPA     pairwise=TKIP     group=TKIP     psk="DEADBEEFCAFEBABE" }

Finitto :-)

[mluis]

Sharing X session between docker and OSX.

socat TCP-LISTEN:6000,reuseaddr,fork UNIX-CLIENT:\"$DISPLAY\" & docker run -e DISPLAY=192.168.99.1:0 ...

[mluis]

Good to know! :)

[mluis]

A joke a day keeps the doctor away!

Install Fortune and Cowsay on your Debian (what else) flavoured system.

Then run:

mkdir /etc/update-motd.d cat > /etc/update-motd.d/10fun << EOF #! /bin/sh fortune -a | cow$(shuf -n1 -e say think) -f $(ls /usr/share/cowsay/cows/ | shuf -n1) EOF chmod a+x /etc/update-motd.d/10fun

And enjoy opening console sessions. :)

[mluis]

“Silent Gratitude Isn’t Much Use to Anyone.” -- Link

[mluis]

This year's bot will be the same as the last one. Loading...

[mluis]

A Raspberry Pi emulated environment on OSX Lion

  An ARM GNU/Linux box for 25$.

"The Raspberry Pi is a credit-card sized computer that plugs into your TV and a keyboard. It’s a capable little PC which can be used for many of the things that your desktop PC does, like spreadsheets, word-processing and games. It also plays high-definition video. We want to see it being used by kids all over the world to learn programming." http://www.raspberrypi.org/faqs

Have passed some time since I heard about the Raspberry Pi for the first time. Now I have friends who already own one and others waiting for their order of it. But it seems to me quite an appealing project since the sooner kids start doing a task, and seeking that they should perform it better over time, prepares them earlier and earlier for a task of higher complexity in favor of one's evolution. :)

What I'll be posting here is about how to set up an emulated environment of Raspberry Pi on OSX and for that we'll need:

A Cross-Compiling Tool for the CPU architecture of RPi. ( eg. ARM EABI Toolchain )

The RPi Kernel.

The RPi root filesystem.

The Emulator (QEMU).

The Cross-Compiling Tool for the ARM architecture.

Let's assume you already have the latest Xcode and command line tools from Apple Developer and homebrew also. 

 So, let's install the dependencies:

brew install mpfr gmp libmpc libelf texinfo

 Grab and compile the tool (more options here if needed):

mkdir ~/rpi

mkdir ~/rpi/arm-cs-tools

git clone https://github.com/jsnyder/arm-eabi-toolchain.git

cd arm-eabi-toolchain

PREFIX=$HOME/rpi/arm-cs-tools make install-cross

make clean

echo "export PATH=$HOME/rpi/arm-cs-tools/bin:$PATH" >> ~/.bash_profile

The RPi Kernel Compilation

mkdir ~/rpi/kernel

cd ~/rpi/kernel

git clone https://github.com/raspberrypi/linux.git

cd linux

Grab the config file and configure the kernel:

cp arch/arm/configs/bcmrpi_cutdown_defconfig .config

make ARCH=arm CROSS_COMPILE=~/rpi/arm-cs-tools/bin/arm-none-eabi- menuconfig

Save the configuration and let's build the kernel afterwards. Note that the compilation should fail and complain about an <elf.h> inclusion in scripts/mod/mk_elfconfig. If it does, one must create the file:

sudo touch /usr/local/include/elf.h

Edit it and write the following:

#include <libelf.h>

#define R_386_NONE 0

#define R_386_32 1

#define R_386_PC32 2

#define R_ARM_NONE 0

#define R_ARM_PC24 1

#define R_ARM_ABS32 2

#define R_MIPS_NONE 0

#define R_MIPS_16 1

#define R_MIPS_32 2

#define R_MIPS_REL32 3

#define R_MIPS_26 4

#define R_MIPS_HI16 5

#define R_MIPS_LO16 6

and follow through the building process:

make ARCH=arm CROSS_COMPILE=~/rpi/arm-cs-tools/bin/arm-none-eabi- -k

The image file is created and located as arch/arm/boot/zImage.

The Emulator

Due to a bug of a white screen hanging QEMU if compiled with llvm one must install the package apple-gcc42 from the homebrew's dupes repository.

brew install homebrew/dupes/apple-gcc42

And then compile and install qemu like:

brew install qemu --use-gcc 

Now we're left with all we need to start the RPi distribution so let's start it like:

qemu-system-arm -M versatilepb -cpu arm1176 -hda debian6-19-04-2012.img -kernel zImage -append "root=/dev/sda2" -serial stdio -usbdevice tablet

And... Voilá!

Happy Hacking! :)

[mluis]

The easy way to the OpenSource IP Multimedia Subsystem.

"The Open IMS Core is an Open Source implementation of IMS Call Session Control Functions (CSCFs) and a lightweight Home Subscriber Server (HSS), which together form the core elements of all IMS/NGN architectures as specified today within 3GPP, 3GPP2, ETSI TISPAN and the PacketCable intiative. The four components are all based upon Open Source software(e.g. the SIP Express Router (SER) or MySQL)."

-- http://www.openimscore.org/

Download & Install libmysqlclient15off from:

http://packages.debian.org/lenny/libmysqlclient15off

Note: To install openimscore-fhoss you'll need to install sun-java6-jre since it depends on it. Add the repositories to your sources.list file.

deb http://glua.ua.pt/~mluis/apt oneiric main contrib non-free

And run:

sudo apt-get update

sudo apt-get install openimscore*

Follow the configuration instructions. And..... you're done.

:-)

[mluis]

OpenCL: An Open standard for heterogeneous parallel computing

"The way the processor industry is going is to add more and more cores, but nobody knows how to program those things. I mean, two, yeah; four, not really; eight, forget it."

Steve Jobs, NY Times interview, June 10 2008

Nowadays, as new hardware platforms evolve, so concepts do. Yesterday, a computer was an unified processing unit. Today it is a heterogeneous machine with processing units growing in number and in processing power as well. Units like CPUs, GPUs or DSPs... So why not take advantage of all these resources? That's where OpenCL comes in.

OpenCL stands for Open Computing Language and is a framework for writing programs that execute across heterogeneous platforms consisting of CPUs, GPUs, and other processors. (...) OpenCL provides parallel computing using task-based and data-based parallelism. [+]

Overview.

(I may leave a conceptional approach on this subject later on.)

The basic hardware platform is composed of a Host and a few Devices made of a few compute units. Each compute unit is made of a few processing elements. The OpenCL platform allows applications to use a host and one or more OpenCL devices as a single heterogeneous parallel computer system. e.g. Multiple cores on CPU or GPU together are a single device and OpenCL executes kernels across all cores in a data-parallel manner.

A Host program in order to perform a very specific task relies on an OpenCL C programming language derived from the ISO C99 with slight differences in keywords and syntax and with some additions and some restrictions. That piece of code should be called a Kernel. The Host program also relies on the OpenCL platform and runtime layer.

Inside this platform there's the OpenCL Runtime layer and allows the host program to create memory objects associated to contexts as well as manipulate contexts once they have been created. It also allows to compile and create kernel program objects, issue commands to command-queue, synchronization of commands and cleaning up OpenCL resources.

Contexts enable sharing of memory between devices. In order to do that, both devices must be in the same context. Contexts are also central elements to manage:

Command Queues (for kernel execution coordination) are ment to store a set of operations to perform and are associated to a context. All work is submitted through queues so each device must have a queue. Multiple command-queues can be created to handle independent commands that don't require synchronization;

Memory objects to transfer or mapping of memory object data, Programs and Kernels.

A Program encapsulate a context, a program source or binary and a list of target devices and build options.

A Kernel is written in OpenCL C and declared with the kernel qualifier. It encapsulates a specific function in a program and is precompiled into a binary format and there are function calls for dealing with module and function loading.

In the OpenCL platform, the compiler is built into the runtime layer and can be invoked on the raw text or a binary can be built and saved for later load.

Running an OpenCL calculation takes these steps.

Writing the Kernel:

const char *ProgramSource = "__kernel void hello(__global float *input, __global float *output)\n"\ "{\n"\ "  size_t id = get_global_id(0);\n"\ "  output[id] = input[id] * input[id];\n"\ "}\n";

Initialization: Selecting a device and creating a context in which to run the calculation

Query platform

Query device(s)

Create a context

1.

cl_uint num_of_platforms=0; cl_platform_id platform_id; // retreive a list of platforms avaible if( clGetPlatformIDs(1, &platform_id, &num_of_platforms)!= CL_SUCCESS ){     printf("Unable to get platform_id\n");     return 1; }

2.

cl_device_id device_id; cl_uint num_of_devices=0; // try to get a supported GPU or CPU device if( clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_CPU, 1, &device_id, &num_of_devices) != CL_SUCCESS ){     printf("Unable to get device_id\n");     return 1; }

3.

cl_context_properties properties[3]; // context properties list - must be terminated with 0 properties[0]= CL_CONTEXT_PLATFORM; properties[1]= (cl_context_properties) platform_id; properties[2]= 0; cl_int err; cl_context context; // create a context with the GPU device context = clCreateContext(properties,1,&device_id,NULL,NULL,&err);

Note: The "best" device is algorithm- and hardware-dependent, so in order to pick the best device for your algorithm it is best to query some device info.

clGetDeviceInfo(device, name, size, *value, *value_size_ret)

Number of compute units: CL_DEVICE_MAX_COMPUTE_UNITS Clock frequency: CL_DEVICE_MAX_CLOCK_FREQUENCY Memory size: CL_DEVICE_GLOBAL_MEM_SIZE

...

Allocation of memory/storage that will be used on the device and push it to the device. Creating memory objects : Programs and kernels are read in from source and compiled or loaded as binary

Create command-queue / Allocation of resources

Create memory object

1.

cl_command_queue command_queue; // create command queue using the context and device command_queue = clCreateCommandQueue(context, device_id, 0, &err); cl_mem input, output; // create buffers for the input and ouput input = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(float) * DATA_SIZE, NULL, NULL); output = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(float) * DATA_SIZE, NULL, NULL); float inputData[DATA_SIZE]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // load data into the input buffer clEnqueueWriteBuffer(command_queue, input, CL_TRUE, 0, sizeof(float) * DATA_SIZE, inputData, 0, NULL, NULL);

2.

cl_program program; // create a program from the kernel source code program = clCreateProgramWithSource(context,1,(const char **) &ProgramSource, NULL, &err); // compile the program if( clBuildProgram(program, 0, NULL, NULL, NULL, NULL) != CL_SUCCESS ){     printf("Error building program\n");     return 1; }

Note: Buffers are simple chunks of memory so Kernels can access them for reading and writing however they like (pointers, arrays, structs). Images can only be accessed via read_image() and write_image(). One image cannot be read and written in the same kernel.

The arguments to the kernel are set and the kernel is executed on all data

cl_kernel kernel; // specify which kernel from the program to execute kernel = clCreateKernel(program, "hello", &err); // set the argument list for the kernel command clSetKernelArg(kernel, 0, sizeof(cl_mem), &input); clSetKernelArg(kernel, 1, sizeof(cl_mem), &output);          size_t global; global=DATA_SIZE; // enqueue the kernel command for execution clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global, NULL, 0, NULL, NULL); clFinish(command_queue); float results[DATA_SIZE]={0}; // copy the results from out of the output buffer clEnqueueReadBuffer(command_queue, output, CL_TRUE, 0, sizeof(float) *DATA_SIZE, results, 0, NULL, NULL);

Tear down.

// print the results printf("output: "); int i; for( i=0;i<DATA_SIZE; i++ ){     printf("%f ",results[i]); } // cleanup - release OpenCL resources clReleaseMemObject(input); clReleaseMemObject(output); clReleaseProgram(program); clReleaseKernel(kernel); clReleaseCommandQueue(command_queue); clReleaseContext(context);

Note: I didn't messed with synchronization neither events.

So let's go for some fun! Grab the code. I'm using a 32bits Ubuntu 10.04 Lucid Lynx with an ATI graphics card.

Let's go for the prerequisites. I had to fetch the drivers from the ATI website.

sudo wget link

sudo chmod +x ./ati-driver-installer-10-7-x86.x86_64.run

sudo ./ati-driver-installer-10-7-x86.x86_64.run --buildpkg Ubuntu/lucid

sudo dpkg -i fglrx-modaliases_8.753-0ubuntu1_i386.deb fglrx-dev_8.753-0ubuntu1_i386.deb fglrx-amdcccle_8.753-0ubuntu1_i386.deb fglrx_8.753-0ubuntu1_i386.deb

rm fglrx-modaliases_8.753-0ubuntu1_i386.deb rm fglrx-dev_8.753-0ubuntu1_i386.deb rm fglrx-amdcccle_8.753-0ubuntu1_i386.deb rm fglrx_8.753-0ubuntu1_i386.deb rm fglrx-installer_8.753-0ubuntu1_i386.changes

Next download the ATI Stream SDK from AMD website.

tar zxvf /path/to/download/ati-stream-sdk-v2.2-lnx32.tgz -C ~

mv ~/ati-stream-sdk-v2.2-lnx32 ~/.ati-stream-sdk-v2.2-lnx32

Add some variables to your .bashrc

export LIBRARY_PATH=$LIBRARY_PATH":/home/YOURUSER/.ati-stream-sdk-v2.2-lnx32/lib/x86/"

export C_INCLUDE_PATH=$C_INCLUDE_PATH":/home/YOURUSER/.ati-stream-sdk-v2.2-lnx32/include/"

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH":/home/YOURUSER/.ati-stream-sdk-v2.2-lnx32/lib/x86/"

Download the icd-registration from AMD website and extract it on the root of your system.

sudo tar zxvf /path/to/icd-registration.tgz -C /

You can now start programming with:

#include <CL/opencl.h>

and compile it like:

gcc foo.c -o foo -lOpenCL

Reference Links:

http://www.macresearch.org/opencl

http://www.haifux.org/lectures/212/

http://sa09.idav.ucdavis.edu/

http://mathnathan.com/

[mluis]

Giving Iceweasel Flash support: a workaround.

After having a X server and a window manager up and running on my eeepc's Debian 5.0 fresh installation it was about time to start surfing the web... One of my favourite websites is Youtube. As I tried to watch a clip I was barried with a message saying that would need to enable javascript on the browser or download the latest flash plugin for it. Then I started looking in the repositories for something with flashplugin and found the package flashplugin-nonfree-extrasound.

# apt-get install flashplugin-nonfree-extrasound

Installed it but nothing.. I couln'd stand without visiting Youtube! Then i decided to download the flashplugin from Adobe's website.

Still with the package from the repo installed I've downloaded Adobe's plugin. It was extracted:

$ tar zxvf install_flash_player_10_linux.tar.gz

Copied to a place where don't bother me:

# cp install_flash_player_10_linux/libflashplayer.so /usr/lib/iceweasel

# cd /usr/lib/iceweasel

The previous plugin from the package was unlinked:

# unlink libflashsupport.so

And the new plugin was linked using the same linkname from the previous plugin:

# ln -s libflashplayer.so libflashsupport.so

And finally I could watch on Youtube at will...

[mluis]

Açorianos: Quem somos?

[mluis]

Mumy look!.. The importance of Responsability.

[mluis]

Android - An Open Handset Alliance Project -

I was invited by NEECT (the representative group of my course students) to speak about the experience I've been taking so far when architecturing and developing applications for embedded devices. I'll speak a little about Android and the Android Framework as well as comparing the differences when developing for other mobile platforms. This talk is free of charge and is open to the academic community. Feel free to join this talk in a chilled atmosphere :)

[mluis]

I've been at the John Lennon's wall in Prague and it was one of the best moments of Zen I've ever had. :)