Recently, I worked on a visual object tracker implemented in C++. The project has several compile configurations and a time-consuming test suite, some parts of which need a GPU not present in my laptop. Because many parts of the code depend heavily on compile configuration, changing them requires recompilation and ideally also retesting of all configurations to make sure that everything works correctly. Since my development laptop not only lacks the GPU needed for testing but also has only four cores, which makes the compilation unnecessarily slow, I looked for an easy way to compile and test the code being edited on a powerful remote server.

Initially, I tried to use git commit and git push to capture the state of the working directory and transfer it to the remote server, but this was not ideal for many reasons. Then I discovered git stash create, which captures the state of the working directory and creates a “volatile” commit object not attached to any branch. This command became the basis of my git-sarah script, which is an acronym standing for git stash and run at host, and you can see find its code below.

With git-sarah script, instead of instructing my editor or IDE to run:


I instruct it to run the following:

git sarah dir -- make

This command copies the current state of the work tree to $HOME/dir on the server and runs make in the directory corresponding to the current directory on the local host. For example, if the current local directory is ~/projects/kcf/src, with kcf being the root directory of the git repository, the make command will be run in $HOME/dir/src on the server. In the output (both stdout and stderr) of the command, the path of the server directory, e.g., /home/mylogin/dir is replaced with its local counterpart: /home/me/projects/kcf.

If a single command (make) is not enough, you can instruct git-sarah to run commands from a script (e.g.,, which need not be stored in your git repository, by running:

git sarah dir -- sh < ./

The code of git-sarah is quite simple:


set -e -o pipefail

git sarah <host> <remote_dir> [ -- ] [ command ... ]

git stash and run at host
h,help    show the help
eval "$(echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)"
echo "$*"
while \[[ $# -gt 0 ]]; do
    case "$1" in
        -h) exit 0;;
        --) shift; break;;

HOST=${1:?Host not specified}; shift
DIR=${1:?Remote directory not specified}; shift
PREFIX=$(git rev-parse --show-prefix)

worktree=$(git stash create)

git push -f $HOST:$DIR $worktree:refs/heads/git-sarah

# Use ssh to translate possibly relative $DIR to the absolute one.
ABS_DIR=$(ssh "$HOST" "cd '$DIR' && pwd")

# Run the command at $HOST and translate its output so that
# file/directory names appear as on localhost. Use perl's \Q to limit
# the possibility of interpretating ABS_DIR as a search pattern.
ssh "$HOST" "cd '$DIR/$PREFIX' && git -c advice.detachedHead='' checkout --detach git-sarah && ${*:?Command not specified}" \
    |& perl -pe "s|\Q${ABS_DIR}\E|$(git rev-parse --show-toplevel)|g"
Posted Sat May 11 00:04:24 2019 Tags:

Transcript of my seminar about Julia language.


1 + 1
3 * 5


x = 1
π  # Enter as \pi<TAB>
α = atan(1/2)

3α + 100

Vectors, Arrays


b=[1 2; 3 4]

Element-wise operations – broadcasting


[sin(i) for i in a]

@time sin.(a) .+ cos.(b);
@time [sin(i) for i in a] .+ [cos(i) for i in b];

c = zeros(size(a))
@time c .= sin.(a).^2 .+ cos.(b).^2;
@. c = sin(a)^2 + cos(b)^2

REPL modes

  • Help

    @doc atan
  • Shell

  • Package manager

    ]add IJulia

Return with backspace


Julia uses dynamic types + type inference.

typeof("Hello world")

Parametric types

[1 2 3]
[1 2;3 4.1]

Abstract types and type hierarchy

Integer <: Number
Int8 <: Integer
Int8 <: Number
Float32 <: Number
Float32 <: Integer


f(x) = x*x
function hello(name)
    return "Hello " * name

→(a,b) = (a+b)/(a-b)

Anonymous functions

filter(x->x>0.5, a)

[x for x in a if x > 0.5]

a[a .> 0.5]

Methods and multiple dispatch

Function can have multiple implementations. The implementation to call is selected based on argument types

f(x::Number) = "Number "*string(x)
f(x::String) = "String "*x

Show examples

@doc atan
typeof(@doc atan)
show(stdout, MIME("text/plain"), @doc atan)
show(stdout, MIME("text/html"), @doc atan)



Example of what is possible with the language. This is not a builtin functionality. Everything is programmed in Julia.

using Unitful
using Unitful.DefaultSymbols
using Unitful: hr

1m + 3cm |> cm |> float
float(cm(1m + 3cm))
1m + 3cm |> cm |> float


10km/hr |> m/s
10km/hr |> m/s |> float
0°C |> K |> float


Plots supports multiple plotting backends.

using Plots

One of several available interfaces to Gnuplot.

using Gaston


  • Inspired by Lisp
  • Work at parse tree level.
  • Can rewrite/generate programs.
  • No separate macro language, macros are written in Julia itself.

Examples (see test suites of many Julia packages):


Tasks & Channels

  • Easy to use parallelism

Jupyter notebooks

using IJulia

Integration with C/C++

Direct call to a function from shared library:

ccall(:clock, Int32, ())
ccall((:clock, "libc"), Int32, ())

Interactive C++

using Cxx

cxx"#include <stdio.h>"
icxx"""printf("Hello world\n");"""
# Passing Julia values to C/C++ functions 
x = 42
@cxx printf(pointer("X is %d\n"), x)

Complex example

Testing a C++ class and plotting results of its work.

using Cxx
import Cxx.CxxCore
using Gaston

cxx""" #include "stepper.cpp" """

# Create C++ object and store it in Julia variable
s = icxx"Stepper(nullptr, 2020, 100, 20);"
# Call a method of C++ object
@cxx s->moveTo(2000)
pos = Int32[0]
freq = Int32[0]
while @cxx s->isMoving()
    @cxx s->periodic()
    # Store values from the C++ object in Julia array for later
    # plotting
    push!(freq, @cxx s->freq)
    push!(pos, @cxx s->getPosition())

# Plot gathered data
plot(x, freq, xlabel="iteration", legend="freq")
plot!(x, [0; pos[2:end] .- pos[1:end-1]]./20e-3, plotstyle="points", color="red", legend="Δpos/T_s")
plot!(x, pos, plotstyle="linespoints", color="green", legend="pos")

# Cxx cannot (yet) change functions once that are defined. Use these
# to commands to “replace” the compiler object, which allows
# redefining the functions.
Posted Fri Apr 26 23:45:50 2019 Tags:

When studying Linux kernel sources, it’s often helpful to use ftrace’s function_graph tracer, which traces function entry and exit points and clearly shows how functions call each other.

Sometimes, it is useful to get such a trace from other code than the Linux kernel. In case of C++ this is pretty easy, but for plain C, it is trickier. I came up with the following to print nice traces. It uses GCC cleanup variable attribute to register a function exit callback.

#include <stdio.h>

int trace_indent = 2;
char trace_filler[] = {[0 ... 99] = ' '};

static void trace_end(const char **func)
    fprintf(stderr, "%.*s}\n", 4*trace_indent, trace_filler);

#define TRACE(format, ...) \
    const char *__tracer __attribute__ ((__cleanup__(trace_end))) = __func__; \
    fprintf(stderr, "%.*s%s(" format ") {\n", 4*trace_indent, trace_filler, __func__, ##__VA_ARGS__); \

It can be used this way:

void bar()

void foo(char *str)
        TRACE("str=%s", str);

int main(int argc, char *argv[])
        TRACE("argc=%d", argc);
        return 0;

When this program is run, it prints:

main(argc=1) {
    foo(str=xxx) {
        bar() {
Posted Sat Aug 25 09:51:02 2018 Tags:

„Slidy“ z mého workshopu na Installfestu. K dispozici i ve formě org-mode zdrojáku, jen je potřeba změnit příponu z .txt na .org.


  • ASCII by mělo být spíš UTF-8, ale to nezní tak „cool“ :-)
  • O mě
    • Pracuji na ČVUT, FEL
    • Embedded systémy (≈ low-level stuff)
    • Emacs používám od r. 1998
    • Patřím k lidem, kteří v Emacsu žijí
    • Vim používám také a nic proti němu nemám :-)


  • Pokud je Emacs označován jako operační systém, org-mode bychom mohli nazvat kancelářský balík
  • Outliner
    • Základní funkcionalita; snaha je, aby další funkce nekomplikovaly použití org-mode jako outlineru.
  • Značkovací jazyk (markup)
  • Prostředí pro přípravu textových dokumentů
  • Tabulkový kalkulátor
  • Kalendář, plánovač, organizér
  • a určitě mnoho dalšího…
  • Dokumentace: «C-h i d m org RET»
  • Nekonečné možnosti konfigurace
  • «M-x customize-group RET org RET»


  • Nadpisy ^*+
    • M-RET – nový nadpis
    • M-šipky, M-S-šipky – změny úrovně či pořadí
    • C-c C-u – o úroveň výš, C-c C-j – skok, info:org#Motion
    • Schovávání: TAB, S-TAB
  • Seznamy
    • odrážkové, číslované, …
    • S-←,→
    • Mnohé klávesové zkratky stejné jako u nadpisů
  • Konverze «C-c *», «C-c -»

Značkovací jazyk (markup)

  • Tučné, kurzíva, podtrženo verbatim, přeskrtnuto, kód α,
  • Tabulky – nejsnadnější zadávaní jednoduchých tabulek do počítače | xxx | yyy «TAB»
  • Obrázky: [[./file.jpg]​]
  • Příklady, zdrojáky se zvýrazňováním syntaxe
    • Zkratky: <e «TAB», <s «TAB»
print("String " + number)


  • [[cíl]​[popis]] nebo [​[cíl]]
  • Web Installfestu «C-c C-l», «C-c C-o»
  • Cíle odkazů
    • URL
    • ./soubor
    • interní odkaz [​[cíl]]

      • * Nadpis obsahující cíl
      • #+NAME: cíl


    • Externí odkazy («C-c l»)
      • [[file:source.c::main(int]] argc
      • (tetris)
      • odkazy na emaily…
  • „Rádiové cíle“: <<<rádio>>> rádio

    Příklad: Rádio bylo vynalezeno roku 1893.


  • Todo – každý nadpis může být položkou „TODO“ «S-←,→»
  • Seznam stavů je konfigurovatelný
  • «C-c a t» – all TODOs = agenda
  • Seznam souborů pro tvorbu agendy (např. jeden .org soubor pro projekt)
  • Scheduled/deadline: C-c C-s, C-c C-d
    • «.» = dnes, «S-šipky»
    • Rozumí i textu: např. „May 1“ nebo „Wed“
  • Záznam odpracovaného času na úkolech «C-c C-x C-i», «C-c C-x C-o»
  • Souhrn splnění podúkolů [/], [%]
  • [ ] Checkboxy «C-c C-c»
  • Tagy u nadpisů :tag:, «C-c C-c»
    • hledání podle tagů: «C-c a m»

Rychlý záznam TODO (capture)

  • Vyžaduje konfiguraci
    • Globální klávesa «C-c c»
    • Šablony - předvyplněný obsah, kam se má „TODO“ uložit
(setq org-capture-templates
 '(("t" "Todo" entry (file+headline "~/org/" "Tasks")
        "* TODO %?\n  %i\n  %a")
   ("j" "Journal" entry (file+datetree "~/org/")
        "* %?\nEntered on %U\n  %i\n  %a")))


  • «C-c C-e»
  • Plain text, HTML, OpenDocument, …
  • Relativně snadná tvorba vlastních exportů (např. Doxygen)
  • Nastavení exportu v hlavičce – «C-c C-e #»


  • Práce se zdrojovými kódy
    • Podpora více jazyků v jednom dokumentu a interakce mezi nimi
  • „Literate programming“
  • „Reproducible research“ (executable documentation)
for i in $(seq 3); do date; sleep 1; done
ls -l

Výsledky vidíme níže:

Wed  8 Mar 10:44:56 CET 2017
Wed  8 Mar 10:44:57 CET 2017
Wed  8 Mar 10:44:58 CET 2017
total 24
-rw-r--r-- 1 wsh wsh 6696 Mar  5 21:52 graph.png
-rw-r--r-- 1 wsh wsh 6232 Mar  8 10:42
-rw-r--r-- 1 wsh wsh 6232 Mar  8 10:44 org-mode.txt

  • Editace: «C-c ’»
  • Spuštění: «C-c C-c»
  • Argumenty v hlavičce
    • :results verbatim drawer

Babel example

Run the benchmark (shell script) on a remote server:

mbw -a -q 10 | awk '{ print $1, $3, $9 }'
0 MEMCPY 2193.945
1 MEMCPY 2334.267
2 MEMCPY 2368.546
3 MEMCPY 2396.358
4 MEMCPY 2411.382
5 MEMCPY 2417.211
6 MEMCPY 2434.867
7 MEMCPY 2436.054
8 MEMCPY 2433.682
9 MEMCPY 2460.025
0 DUMB 2494.388
1 DUMB 2513.826
2 DUMB 2511.301
3 DUMB 2508.781
4 DUMB 2506.894
5 DUMB 2510.67
6 DUMB 2508.151
7 DUMB 2518.892
8 DUMB 2475.86
9 DUMB 2465.483
0 MCBLOCK 3248.863
1 MCBLOCK 3172.589
2 MCBLOCK 3161.555
3 MCBLOCK 3175.611
4 MCBLOCK 3184.713
5 MCBLOCK 3174.603
6 MCBLOCK 3164.557
7 MCBLOCK 3170.577
8 MCBLOCK 3166.561
9 MCBLOCK 3188.776

Gnuplot code to plot the results of the above command.

set key right bottom Left
set grid
set title "mbw results"
set xlabel "Attempt"
set ylabel "Bandwidth [MiB/s]"
set style data lp
set yrange [0:]
plot "< grep MEMCPY ".data  using 1:3 title "MEMCPY", \
     "< grep DUMB ".data    using 1:3 title "DUMB", \
     "< grep MCBLOCK ".data using 1:3 title "MCBLOCK"



  • «C-c C-x p»
  • Key-value přiřazené k nadpisu
  • Může měnit různé nastavení pro danou sekci
  • Lze používat i jako jednoduchou databázi (hledání podle properties apod.)
  • Column view «C-c C-x C-c»
Posted Wed Mar 8 11:06:41 2017 Tags:

I started using KiCad (version 4.0.1) for electronic design. It seems to be a great tool, but working with big connectors in schema editor is tedious. All connections have to be done manually and thus the process is error prone. Some way of automating the process would help. KiCad comes with scripting support, but unfortunately only in pcbnew. Eeschema seems not to have any support for automation yet. Hopefully, one can use xdotool under Linux to automate some boring tasks.

I wanted to attach the same labels to FMC connector pins as on the MicroZed FMC Carrier board – there is about 70 pins used. My initial state was this:


I copied the pin names and net labels from the original schmatic in PDF and put together the script bellow, which takes care of attaching the labels to the right pins. So after a few seconds I got the following:


The Python script that does the magic is here:

#!/usr/bin/env python3

import subprocess

conn = [
    ("LA06_P", "C10"),
    ("LA06_N", "C11"),
    ("LA10_P", "C14"),
    ("LA10_N", "C15"),
    ("LA14_P", "C18"),
    ("LA14_N", "C19"),
    ("LA18_CC_P", "C22"),
    ("LA18_CC_N", "C23"),
    ("LA27_P", "C26"),
    ("LA27_N", "C27"),

    ("LA01_CC_P", "D08"),
    ("LA01_CC_N", "D09"),
    ("LA05_P", "D11"),
    ("LA05_N", "D12"),
    ("LA09_P", "D14"),
    ("LA09_N", "D15"),
    ("LA13_P", "D17"),
    ("LA13_N", "D18"),
    ("LA17_CC_P", "D20"),
    ("LA17_CC_N", "D21"),
    ("LA23_P", "D23"),
    ("LA23_N", "D24"),
    ("LA26_P", "D26"),
    ("LA26_N", "D27"),

    ("CLK1_M2C_P", "G02"),
    ("CLK1_M2C_N", "G03"),
    ("LA00_CC_P", "G06"),
    ("LA00_CC_N", "G07"),
    ("LA03_P", "G09"),
    ("LA03_N", "G10"),
    ("LA08_P", "G12"),
    ("LA08_N", "G13"),
    ("LA12_P", "G15"),
    ("LA12_N", "G16"),
    ("LA16_P", "G18"),
    ("LA16_N", "G19"),
    ("LA20_P", "G21"),
    ("LA20_N", "G22"),
    ("LA22_P", "G24"),
    ("LA22_N", "G25"),
    ("LA25_P", "G27"),
    ("LA25_N", "G28"),
    ("LA29_P", "G30"),
    ("LA29_N", "G31"),
    ("LA31_P", "G33"),
    ("LA31_N", "G34"),
    ("LA33_P", "G36"),
    ("LA33_N", "G37"),

    ("CLK0_M2C_P", "H04"),
    ("CLK0_M2C_N", "H05"),
    ("LA02_P", "H07"),
    ("LA02_N", "H08"),
    ("LA04_P", "H10"),
    ("LA04_N", "H11"),
    ("LA07_P", "H13"),
    ("LA07_N", "H14"),
    ("LA11_P", "H16"),
    ("LA11_N", "H17"),
    ("LA15_P", "H19"),
    ("LA15_N", "H20"),
    ("LA19_P", "H22"),
    ("LA19_N", "H23"),
    ("LA21_P", "H25"),
    ("LA21_N", "H26"),
    ("LA24_P", "H28"),
    ("LA24_N", "H29"),
    ("LA28_P", "H31"),
    ("LA28_N", "H32"),
    ("LA30_P", "H34"),
    ("LA30_N", "H35"),
    ("LA32_P", "H37"),
    ("LA32_N", "H38"),
]["xdotool", "search", "--name", "/FMC/", "windowfocus"])
xtab = str.maketrans({"_": "underscore"})
for net in conn:
    label = [char.translate(xtab) for char in net[0]]
    pin = [char.translate(xtab) for char in net[1]]["xdotool", "key", "--delay", "50", "ctrl+f"] + pin + ["Return", "Escape", "Down", "Left", "Left", "Left", "w",
                     "Left", "Left", "Left", "Left", "Left", "Left", "Left", "Left",
                     "Left", "Left", "k", "l"] + label + [ "Return", "Return"])
Posted Sun Jan 10 15:03:28 2016 Tags:

Osnova, podle které jsem jel na dnešním workshopu na Installfestu.

1 Co je Emacs?

  • Všestranný textový editor
  • Interpret Lispu (v jazyce C) + spousta Lispového kódu
    • C: 280 kLoC (20%), Lisp: 1 MLoC (80%)
    • Srovnání – Firefox: 6 MLoC C/C++, 3.6 MLoC JavaScript+HTML
  • Emacs = Editor MACroS nebo Esc-Meta-Alt-Ctrl-Shift :)
  • Plnohodnotný operační systém :) (M-x tetris, M-x doctor)
  • Začal vznikat v 70. letech


2 Terminologie

  • Poplatná době vzniku
  • Buffer = otevřený soubor
  • Okno (window) = část obrazovky editoru zobrazující buffer
    • Jedno okno zobrazuje právě jeden buffer
    • Jeden buffer může být zobrazován nula až N okny
  • Frame = to čemu dneska říkáme okno
    • Může být grafický nebo textový (terminál)

3 Základní klávesové zkratky

  • Mnoho jich je stejných jako v bashi
  • Dobře se používají i na exotických klávesnicích (kámošův notebook, BT klávesnice k mobilu/tabletu, …)
  • Notace: C = Control, M = Meta = Alt = Esc, S = Shift

3.1 Kurzor

  • C-b = backward char, C-f = forward char, C-p = prev line, C-n = next line
  • M-b = backward word, M-f = forward word, M-p = prev ???, M-n = next ???
  • C-a = home, C-e = end
  • M-a = backward sentence, M-e = forward sentence

3.2 Mazání

  • C-d = znak, M-d = slovo
  • C-k = do konce řádky

3.3 Příkazy

  • C-x C-f = find (open) file
  • C-x C-s = save file
  • C-x C-c = “exit”
  • C-x u, C-_, C-/ = undo

Pozn.: C-x je tzv. prefixová klávesa, podobně jako Esc

  • C-l = redisplay, center, …
  • C-g = přeruší právě vykonávanou operaci (mačkat, když Emacs nereaguj)

3.4 Hledání

  • C-s = interactive search, C-M-s = interactive regexp search
  • C-r = reverse search

3.5 Prefix/numeric argument

  • Neplést s prefixovou klávesou
  • Mnohým příkazům (klávesovým zkratkám) lze předat číselný parametr
  • Většinou to znamená opakování
  • C-u 8 C-f – posun o 8 znaků doprava
  • M-8 C-f – to samé
  • C-u samotné modifikuje některé příkazy i bez čísla (C-u C-x C-c = vše ulož a “exit”)

4 Příkazová řádka

  • M-x <příkaz>
  • Mini-buffer – většina klávesových zkratek stejná jako při editaci normálních bufferů (souborů)
  • tab-completion
  • completion “modes”
  • Příkaz je lispovská funkce označená jako (interactive).
  • Klávesové zkratky spouští příkazy – viz (global-set-key ...).

5 Velké (major) a malé (minor) módy

  • V Emacsu se vše motá kolem “módů”
  • Velký mód:
    • definuje zvýrazňování syntaxe,
    • definuje klávesové zkratky,
    • implementuje (automatické) zarovnávání kódu,
    • vybírá se automaticky podle přípony nebo obsahu souboru,
    • lze ho vybrat i manuálně (spuštěním příkazu *-mode; např. c-mode).
  • Malý mód:
    • Implementuje dodatečnou funkcionalitu, kterou má smysl používat s vícero velkými módy.
    • Příklady:
      • flyspell-mode
      • auto-fill-mode
      • hide-show-mode
  • Jaké módy jsou momentálně aktivní naznačuje Mode line.

6 Přístup k nápovědě

  • Emacs má poměrně dobrý systém nápovědy.
  • C-h prefix key
    • C-h f – funkce
    • C-h v – proměnné
    • C-h k – klávesová zkratka
    • C-h m – mód
    • C-h i – prohlížeč info stránek (C-h i m Emacs <RET>)
      • Navigace: ‘n’, ‘p’, ’[’, ’]’
      • ’i’ – hledání v rejstříku (pak ’,’)
  • M-x man

7 Bloky (region, rectangle)

  • Nové verze Emacsu (konečně) podporují výběr pomocí S-<šipky>.
  • Tradičně: blok je oblast od “značky” ke kurzoru (point).
  • C-SPC = polož značku
  • Ctrl-C, Ctrl-V, Ctrl-X – standardně nefunguje, lze zapnout M-x cua-mode.
    • Ctrl-C koliduje s mnoha standardními zkratkami; cua-mode to částečně řeší.
  • Tradičně:
    • Smazaný text se ukládá do “kill ringu” (např. C-k, M-d)
    • C-y (yank) vloží hodnotu z konce “kill ringu”
    • M-y (následující po C-y) vkládá starší hodnoty z “kill ringu”.
    • C-w = kill region
    • M-w = “copy” region
  • Obdélníkové bloky
    • C-x r * – neintuitivní (aspoň pro mne)
    • C-x SPC = rectangle mark mode
      • M-x string-insert-rectangle – vloží stejný text na každou řádku bloku
    • CUA mode: C-RET = cua-set-rectangle-mark
      • string-insert-rectangle není potřeba; stačí začít psát
      • ve výjimečných případech se chová podivně

8 Správa oken a bufferů

  • Správa oken
    • není ideální
    • C-x 2, C-x 3 = rozděl okno vertikálně/horizontálně
    • C-x o = přesun na následující okno
    • Windmove package – pohyb mezi okny podle směru (např. S-<šipky>)
    • C-x 0 = smaž aktuální okno (ale ne buffer)
    • C-x 1 = smaž ostatní okna
  • Přepínání bufferů
    • C-x <left>/<right>
    • C-x b = zadat název bufferu (použitelné s completion módy)
    • C-x C-b (polo) interaktivní výběr bufferu
    • M-x ibuffer = interaktivní výběr bufferu
    • M-x helm-buffer-list = dtto

9 Užitečné příkazy/klávesové zkratky

  • M-q = přeformátování odstavce (v mnoha módech inteligentní)
  • C-s = interactive search, C-M-s = interactive regexp search
    • V příkazové řádce hledání:
      • C-s – minulé hledání
      • C-w – doplní slovo pod kurzorem
      • M-c – přepne rozlišování malých a velkých písmen
      • M-e – editace (např. minulého hledání po C-s C-s)
  • M-% = nahrazení řetězce
  • C-M-S-% = nahrazení regulárního výrazu
  • M-/ = doplň rozepsané slovo podle předchozích slov
  • Macros: F3 = začátek nahrávání, F4 = konec nahrávání/spuštění
  • Nahrazení textu ve víc souborech najednou: M-x dired-mode, mark (m), Q
  • M-x occur
  • M-x rgrep
  • M-; comment-dwim (do what I mean)
  • C-M-a = beginning-of-defun, C-M-e = end-of-defun
  • C-M-p, C-M-n, C-M-u = pohyb po závorkami ohraničených blocích (prev, next, up)
  • C-u C-SPC – návrat na místa předchozí editace

10 Konfigurace, “Customization”

  • Možnosti konfigurace jsou nekonečné
  • Předkonfigurovaný Emacs: Emacs Prelude
  • Standardní konfigurační soubor ~/.emacs nebo ~/.emacs.d/init.el.
    • Nastavování proměnných
    • Konfigurace klávesových zkratek (global-set-key (kbd "C-c w") 'toggle-truncate-lines)
    • Definice vlastních příkazů
    • Zapínání minor módu
  • Customization
    • User Hacker-friendly konfigurace
    • +GUI+TUI pro konfiguraci skoro všeho
    • M-x customize
    • M-x customize-{variable,face,group}
    • Není potřeba ručně editovat ~/.emacs

11 File/directory-local variables

  • Konfiguraci Emacsu lze ukládat i do editovaných souborů.
  • Podobně je možné konfiguraci uložit do souboru .dir-locals.el a pak bude platit pro všechny soubory v daném adresáři a jeho podadresářích.
  • M-x add-file-local-variable
  • M-x add-dir-local-variable
/* Local Variables: */
/* compile-command: "make CFLAGS='-g -O0 -Wall" */
/* End: */

12 Programování

  • Odsazování
    • většinou automatické, nebo po <TAB>
    • inteligentní zarovnávání všeho
      • ’M-q’ v komentáři zarovná komentář
  • Kompilace
    • M-x compile, M-x recompile
    • M-x next-error (skáče na chyby, detekce mnoha kompilátorů/formátů chybových hlášení)
  • Doplňování kódu
    • auto-complete-mode
    • company-mode (asi lepší)
    • yasnippet (TextMate snippets in Emacs)
  • Často možnost interakce s interpretrem skriptovacích jazyků (např. v M-x python-shell-send-defun)
  • Verzovací systémy
    • vc – stejné klávesové zkratky pro všechny VCS (např. C-x v = – diff aktuálního souboru)
    • magit – speciální mód pro práci s gitem

13 Užitečné módy

  • auctex – pokročilý editor na *TeXové dokumenty
    • navigace po sekcích, promote/demote sekcí
    • integrace s BibTeXem pro snadné hledání/vkládání citací
    • náhledy rovnic a obrázků přímo v editovaném textu
  • org-mode – tvorba a organizování poznámek, TODO seznamů, plánování projektu, tvorba dokumentů atd.
    • tato prezentace je v org módu
  • dired-mode – správa souborů
    • C-x d, C-x C-f (adresář)
    • mazání souborů: označit ‘d’, smazat ‘x’
    • vzdálená editace (kompilace, …) souborů
    • SSH, sudo, …
  • notmuch – lokální “gmail” (rychlé vyhledávání), GUI v Emacsu
  • shell, eshell – práce s příkazovou řádkou bez opuštění Emacsu

Instalace balíků třetích stran:

  • M-x list-packages
  • MELPA repozitář balíků

14 emacsclient

  • Emacs většinou dlouho startuje
  • Doba startu záleží na uživatelské konfiguraci
    • Inicializace balíků při startu vs. autoload
  • Emacs lze pustit jako “server” (emacs --daemon) a připojovat se k němu pomocí programu emacsclient.
    • Nic se nemusí konfigurovat, emacsclient si spustí emacs sám:

      exec emacsclient -a '' "$@"
  • K jednomu serveru se lze připojit současně z různých terminálů (lokálně X-windows, vzdáleně přes SSH).

15 Úvod do Emacs Lispu

  • (Emacs) Lisp
    • C-h i m Elisp <RET>
    • Je jednodušší než např. Common Lisp
    • Program i data vypadají stejně (S-výrazy/S-expressions/sexp)
    • Vyhodnocení výrazu:
      • číslo je číslo, řetězec je řetězec
      • seznam: první prvek udává jméno funkce, ostatní prvky jsou parametry.

        (message "Ahoj")
        (message (concat "Ahoj" "Installfest"))
    • Proměnné:
      • globální:

        (defvar xyz 0)
      • lokální:

        (let (a b)
    • Funkce:

      (defun fs-czech ()
        "Starts flyspell with czech dictionary"
        (interactive) ; Způsobí, že fs-czech se dá spustit pomocí M-x
        (ispell-change-dictionary "czech")

16 Příklad použití elispu

  • Navigace po framech v LaTeX beameru

    (defconst latex-beamer-frame-re         ; Regulární výraz, který budeme hledat
      "\\\\\\(frametitle\\|section\\){")    ; '\' se musí 2x escapovat
    (defun is-outside-of-comment ()
      (null (nth 8 (syntax-ppss))))
    (defun latex-beamer-previous-frame ()
      (while (progn
               (re-search-backward latex-beamer-frame-re)
               (not (is-outside-of-comment))))
      (recenter 0))
    (defun latex-beamer-next-frame ()
      (when (looking-at-p latex-beamer-frame-re)
      (while (progn
               (re-search-forward latex-beamer-frame-re)
               (not (is-outside-of-comment))))
      (goto-char (match-beginning 0))
      (recenter 0))
    (add-hook 'LaTeX-mode-hook (lambda ()
      (local-set-key (kbd "M-p") 'latex-beamer-previous-frame)
      (local-set-key (kbd "M-n") 'latex-beamer-next-frame)))

17 In-line elisp

  • C-x C-e = vyhodnoť výraz před kurzorem (point)
  • Kusy elispu lze vkládat do komentářů programů v jiných jazycích a spouštět přímo tam.
\chapter*{List of Acronyms}

% Sort acronyms: (let ((sort-fold-case t)) (sort-regexp-fields nil "^[[:space:]]*\\\\acro\{\\([^}]*\\)\}.*$" "\\1" (search-forward "\\begin{acronym}") (search-forward "\\end{acronym}")))
  \acro{AC}{Access Category}
  \acro{BFQ}{Budget Fair Queuing}
Posted Sun Mar 8 17:10:35 2015 Tags:

Stejně jako vloni jsem měl i letos přednášku na InstallFestu. Tentokrát to bylo o nástroji novaboot, který už přes dva roky vyvíjím a používám jej k mnoha zajímavým věcem. Některé z nich jsem během přednášky zmínil a najdete je ve slidech.

Při přednášce se dostavil klasický “demo efekt”, tedy že to, co ještě ráno fungovalo, fungovat přestalo. Nemohl za to novaboot, ale pochybná implementace technologie Intel AMT na mém počítači. Naštěstí jsem měl ještě jeden počítač, se kterým novaboot fungoval, ale bohužel jsem na něj neměl otočenou web kameru, takže se návštěvníci museli spokojit jen s výstupem na mém terminálu.

Slidy k přednášce:
Slidy k přednášce
Posted Tue Mar 4 09:47:30 2014 Tags:

I use Matlab/Simulink R2012b under Linux to model dynamic systems. In order to perform hardware-in-the-loop testing, I want to run my models in real-time on Linux with rt_preempt patch. Running a Simulink model in real-time can be achieved by converting the model to the C code, compiling it and running the resulting application. Simulink supports this by means of Simulink Coder. Producing a Linux application with Simulink Coder is not as straightforward as one might think, though.

About Simulink Coder

Simulink Coder (formerly called Real-Time Workshop) can generate the code in many styles and for several platforms and operating systems. Surprisingly, Linux is also among supported environments.

Simulink Coder can, by default, generate code for so called Generic Real-Time Target (GRT). Such code should be suitable for running on desktop platforms. If you want to run the code on a more constrained embedded system or you have additional requirements on the code (e.g. compliance with safety standards), there is Embedded Coder for you. Embedded Coder extends Simulink Coder with additional capabilities and targets. The default Embedded Coder target is called Embedded Real-Time Target (ERT).

As it turns out, neither GRT nor ERT target alone can be used to create Linux executable even if documentation says the opposite.

Available options for generating Linux applications

From the documentation it seems that there are several options available out of the box that allow to generate Linux applications from Simulink. They are:

  1. The use of Embedded Real-Time target (ert.tlc) and selecting NativeThreadExample as the target operating system in Model Configuration → Code Generation → Templates.

    When I tried to generate the code, I got this error:

    This model specifies the ‘Target operating system’ as ‘NativeThreadsExample’ from the ‘Template’ section of the ‘Code Generation’ pane of the Configuration parameters dialog. This example target is currently supported only when the model is configured for concurrent execution.

    After some searching, I figured out how to enable concurrent execution. It can be done at View → Model Explorer → right click on Configuration → Show Concurrent Execution options and then check Allow tasks to execute concurrently on target. Even though I enabled this and configure the tasks, I still got the same error.

  2. The second option might be using the IDE Link Target that allows to compile the generated code by Eclipse IDE. Even though I don’t like Eclipse, I tried to set it up according to the documentation. Again no success. I ended up with some strange errors suggesting that there is a problem with Eclipse (more precisely its JVM) being a 32 bit application and Matlab a 64 bit application. My guess is that this feature is tested only on Windows. Since Matlab R2012b is not distributed for 32 bit Linux, it is not possible to test this option with 32 bit Matlab. Furthermore, in release notes of R2013a it is announced that Eclipse support will be dropped in future releases.

Custom target for Linux applications

Simple target

Since I failed with both above options I decided to write a custom code generation target for Linux. One option would be to use a target previously developed at our department, but it has several drawbacks:

  1. The generated code cannot be compiled. It seems that the interface to the generated code changed between Simulink version from 2007 (when the target was developed) and R2012b used by me.
  2. I don’t like that the target is meant to be used on Windows (hardcoded backslashes etc.) and additionally,
  3. it contains features that I do not need (CANOpen block set).

Therefore I decided to write my own target that should be as simple as possible.

After creating the target by copying the ert.tlc file and modifying it slightly (basically replacing ert with ert_linux) and selecting NativeThreadsExample as in the step 1 above, the code was successfully generated. You can see this target here. Such a target has two problems:

  1. It does not support external mode, i.e. a mode in which Simulink can connect to the running application to provide on-line parameter tuning and real-time data plotting.
  2. The generated code uses POSIX timers that use signals to wake up the threads. Signals have quite big overhead and there are rumors that their delivery can suffer from priority inversion.

The only way to get Linux application with support for external mode seemed to develop a target with custom main.c file.

Advanced target

I developed the target that provides the main.c file (actually called ert_main.c) and supports external mode. Although the documentation is quite extensive (several thousands pages in total), if was really hard to figure out how to do it properly. Several times it was necessary to study awful TLC1 source code which is, IMHO, very badly structured. Fortunately, I could use Lukáš Hamáček’s target as an example, which helped me a lot.

The result of my work is can be downloaded from our repository. The target has the following features:

  • Support for external mode over TCP.
  • Support for both single-rate and multi-rate systems.
  • Simulation threads are scheduled as SCHED_FIFO (real-time priority).
  • External mode communication runs in non-real-time thread.

I tested the target on several systems and everything seemed to work as expected. My only concern now is about thread safety. Given that Simulink produces the error messages about concurrent execution of threads (see above), I’m not sure whether the generated code can be safely run in multiple threads. Also the code implementing external mode server contains several semaphores but only when it is compiled for the VxWorks OS. I’ll probably check this later if we encounter any problems that might be caused by the code not being thread safe.


It is surprising how few relevant results Google gives when one asks for ”simulink real-time workshop linux”. It seems that the Embedded Coder target for Linux described in this post might be useful for people waning to run their Simulink models on Linux. Although that the target may not work perfectly and in all configurations, I think it is now good enough for interested people to try. If you experience any problems with the target, let me know.



Target Language Compiler – the tool used to convert Simulink blocks to C code.

Posted Thu Jul 25 17:36:07 2013 Tags:

Na letošním InstallFestu jsem měl přednášku o použití Linuxu v robotech. Snažil jsem se ukázat, jak lze z Linuxu běžícím na nějaké “embedded” desce ovládat hardware k ní připojený. Všechny praktické ukázky, které jsem měl připravené, se povedly, až na tu poslední – robot v akci. Ale tu jsem nahradil videem z finále Eurobotu 2010.

Slidy k přednášce:
Slidy k přednášce

Update: Video záznam z přednášky je k dispozici na stránkách InstallFestu.

Posted Mon Mar 4 12:25:29 2013 Tags:

I have an ikiwiki-based website that is used for a university course. Every student has a page where she is supposed to provide information about a project being worked on. For this I want to authenticate students so that they can only edit their page. So far the authentication was implemented with unixauth plugin and the server used PAM modules to authenticate against LDAP server. This worked sufficiently well, however, this method was deprecated by our university IT. Instead, they want all web applications to use Shibboleth technology. I was surprised how easy it is to make ikiwiki work with Shibboleth.

Shibboleth project distributes Apache module modshib2 (libapache2-mod-shib2 package under Debian) that, when properly configured, does the whole authentication for you. Its configuration is not particularly easy but, with the documentation from our IT department, it was possible to do it. When everything is configured, the identity of the authenticated user is passed to the web application in REMOTE_USER environment variable (and a few other variables may contain additional attributes). The use of REMOTE_USER means that one can use the httpauth plugin and Shibboleth authentication works out of the box.

It is sufficient to follow httpauth documentation and add this configuration to your Apache server.

<Directory /var/www/osp/auth>
    Options +ExecCGI -Indexes

    AuthType shibboleth
    ShibRequestSetting requireSession 1
    Require valid-user

    <Files ikiwiki.cgi>
        SetHandler cgi-script

That’s all.

Posted Thu Jan 31 13:59:19 2013 Tags: