Category: Allgemein

Posted on

Audio Setup Improvements

After almost a full year of working from home and numerous video conferences in different software solutions, I have finally upgraded my audio equipment. Initially I wanted to revive my old Tascam US122L, but it seems that all solutions I found to get that device working in Linux are outdated by now.

TL;DR
I bought a Focusrite Scarlett 2i2 3rd Gen USB audio interface*, a the t.bone condenser microphone, and a desk stand for the microphone. I am very satisfied with the overall setup quality and the sound it produces, although I would buy a different desk stand next time.

Longer Story

I have been looking into beginner’s home recording equipment for some time due to my general interest for it. Since, generally speaking, time is the most limiting factor, I never considered buying any of the equipment, as I thought I would never use it. With the pandemic changing the way I work and interact with my colleagues etc, these things have changed, and I finally had an excuse to spend some money.

I had two requirements that the audio interface needs to fulfill:
1. I want a two channel / stereo interface with somewhat decent pre-amps, and,
2. it needs to work on Linux (and potentially Windows).

After spending some time searching the internet, I finally came by the Scarlett series by Focusrite. It seems that their (smaller) interfaces are USB class compliant, meaning that they work with the Linux built-in USB stack – which I can confirm (Manjaro Linux, Kernel 5.11). The reviews for the pre-amps read decent, and it is not excessively expensive. So far, I can only agree and conclude that I like the sound, and knobs and casing look and feel very high quality.

As microphone, I went with more of a budget solution: the “the t.bone SC 400” condenser microphone. Though it is comparably affordable, I think it offers a decent and rich sound. I do feel, however, that it lacks some airiness in the high frequencies.

If you are interested in a little voice demonstration, the audio setup is the one I use for my twitch live streams. So don’t hesitate and join me for some demo of the sound on Wednesday night.

Posted on

I’m now on twitch!

Yes that’s right! I’m now on twitch!

I have lately started to stream some programming and building games live on twitch.tv/jplehr and found that quiet relaxing and nice. So I want to continue it with a schedule. I’m happy if people join-in to chat, learn more about the software that I work on, maybe about programming in general, or whatever we want to chat about.

Wednesday from 09 PM CET: Programming

Every Wednesday from 09.00 pm CET to about midnight, I am continuing on one of the software packages that I introduce on this website. Currently, I am mostly working on MetaCG or PIRA. Both can also be found on Github.

Sunday from 09 PM CET: Open Stream

I’ll probably also stream on Sunday’s, from 09.00 pm CET to about midnight. But on Sundays, it’ll not only be programming. Other stuff I want and can stream, given the current computers I have, are OpenTTD or Cities Skylines. So some relaxing building and development games. That may change obviously. 😉

So, if you want to know what’s coming up, follow me on twitter or twitch and receive updates and notifications on what I’ll be doing.

Posted on

Changes to this website

I have decided that I want to use this website not only for notes taking – which quite honestly never really happened – but write about what I do. While this includes some of the computer science stuff that is here already, it will open up the variety of things a little bit.

So: what to expect?
Well: I don’t know for sure, yet. But it will be closer to what you can find on my twitter.

Computer Science and High Performance Computing

This part, which was the only thing I considered for now, will still be here. Most of this is also relevant for my daytime job and my research.
Actually, I want to increase this to not only little notes that helped me from time to time but to what I do. Also, I figured it can be interesting to provide pointers to some other great work of people that I work or just some other tools that I find helpful and enjoy.

Hence, I will probably introduce a *software* section (or tag) that includes (research) software that I use, enjoy, develop, want to promote, etc.

Sports

I also enjoy doing sports quite a bit, and decided that I am going to share some of what I do on this website as well. This probably includes some links to training data as well as gear that I use. No false expectations here: I’m not nearly as much of an athlete as I would like to be. But I do some sports and want to share some of my experiences.

Other free-time activities

Finally, I’ll also add some other free-time activities. I have a couple of very, very easy woodwork things on my list that I may share little stories of. However, this will be (I guess) the smallest part of what I add to the website.

Posted on

HPC Hallway

As a result of the Covid 19 / Coronavirus situation, an informal weekly meeting, known as the HPC huddle, established itself. It offers a room for discussion around HPC, AI, cloud, and other, related, topics.

To preserve the shared links, we decided to create a Slack. You can find the join link at www.hpc-hallway.org

During conferences, such as ISC or SC, the meeting frequency may increase, to offer more room for discussion and informed speculation.

Posted on

Name mangling in C++ with Clang and GCC

I recently came across the question whether it is possible to use lists of mangled function names (generated with a Clang-based tool) in a GCC compiler plugin. I am aware that name mangling is compiler dependent and not standardized, yet I had hopes that this would be something I can achieve.

I started with a quick web search. That, however, did not lead to satisfying answers, as I was still unsure whether it could actually work. Most of the answers I found were about the status when GCC 5 came out. Now, I am working with GCC 8 and things may change.

So, I continued by implementing very basic test cases to start this off experimentally, i.e., to get an idea on whether more reading about all this is worth my time. Codes were as simple as the one shown below. The first name in the comment is the GCC mangled name (g++ 8.3) and the second name is the Clang mangled name (clang++ 9.0).

void foo() {} // _Z3foov == _Z3foov
void foo(int a){} // _Z3fooi == _Z3fooi
double foo(double d){return 0;} // _Z3food == _Z3food
void foo(int a, double d) {} // _Z3fooid == _Z3fooid
namespace test {
 void foo(int a) {} // _ZN4test3fooEi == _ZN4test3fooEi
 double foo(double d) {return 0;} //_ZN4test3fooEd == _ZN4test3fooEd
}

So, at least given this small set of samples, there do not seem to be differences. I did similar tiny-scale experiments for classes and templates. All of them were simple enough to not discover differences. Eventually, I applied both compilers to a basic C++ implementation of the game of life (sources) and filtered the object code to get a list of all the function names in the resulting binary. I compiled at optimization level 0 to let the compiler not do inlining or other optimizations. I’m sure listing all functions in an object can be done much easier (e.g., using nm), but this is what I did (accordingly for a version of the code compiled with g++):

objdump -d clang++90.GoL | grep ">:" | awk '{ print $2 }' | sed -e "s/://" | uniq | sort > clang++90_names

Inspecting both lists of generated function names, I found differences. In particular, in the mangled name of the constructor of the GameOfLife class.

class GameOfLife {
  public:
    GameOfLife(int numX, int numY) : dimX(numX), 
                                     dimY(numY), 
                                     gridA(dimXdimY,
                                     gridB(dimXdimY){}
    // other members are omitted
};

The constructor is mangled into _ZN10GameOfLifeC1Eii by GCC and into _ZN10GameOfLifeC2Eii by Clang. The difference is the C1 vs. the C2 in the name.

Now, I wondered: what is encoded by these C1 / C2 parts of the mangled name? I know that Clang mangles the names according to the Itanium IA64 ABI specification. A quick web search lead me here and so I searched for the respective section of the specification. I found that the specification lists the following in 5.1.4.3 Constructors and Destructors.

  <ctor-dtor-name> ::= C1	# complete object constructor
		   ::= C2	# base object constructor
		   ::= C3	# complete object allocating constructor
		   ::= D0	# deleting destructor
		   ::= D1	# complete object destructor
		   ::= D2	# base object destructor

So, GCC treats the constructor of the GameOfLife class as a complete object constructor, whereas Clang treats it as a base object constructor.

At that point I did not continue digging deeper on why that is the case, i.e., thoroughly reading the IA64 ABI specification definitions, as for me it is sufficient to know that the differences in name mangling occur at such fundamental features as constructors. However, maybe, if someone (or a future me) has the same question (again), I thought I share this in order to know where to start looking for more detail.

Finally, the overall result of this small research is that I will need to write an LLVM plugin to mimic the functionality of the respective GCC plugin I wanted to use in my toolchain. Nothing too bad, but I would have been happier if I could just use the already available GCC plugin.

Posted on

Overleaf for collaborative writing

We started to use Overleaf for collaborative writing of our research papers. After a few papers and other documents, I decided I share my experiences with it.

First, what did we do before we started using Overleaf?

Well, we used a git repository for the paper to synchronize the changes between different authors. Everybody used their favorite text editor and we agreed on some code style. My experience was that the most important thing is: write one sentence per line, because it makes merging just so much easier. Then we would send the pdf of the draft to whoever is doing the internal review. We get back a paper copy with handwritten remarks to be included and iterate the whole process. This isn’t bad, and I totally understand if people prefer to read on a printed out copy.

Now, how did Overleaf change this?

Overleaf is a little bit like multiplayer LaTeX. What we found to be more important: it sets up the pdf version of the paper immediately. This is particularly helpful for the internal review – at least in our group. With its comment mechanism, people can simply annotate the respective parts of the document. If they only found a typo, they can also immediately fix it in the document. This makes the review easier and faster accessible. I would, however, agree that the introduction of Overleaf is not the most important thing that ever happened.

That’s all great! What can’t it do?

I found it to be somewhat annoying that the editor is an always-on solution! You cannot, at least I did not see how, make the document / editor available offline to, say, work on a document while flying across the Atlantic [Yes, I am assuming you do not want to use the WiFi in the plane]. If you dig a little bit into it, you find that the Overleaf document is actually a git repository behind the scenes. Let’s just clone it, so we can work offline and then push the changes. Unfortunately, you can’t do this. The first part worked smoothly: cloning the project’s git. The second part, pushing changes to it, failed. At least I did not manage to add my credentials in a way that allowed me to push changes to the remote.

So what’s the conclusion?

My conclusion is: Overleaf provides a convenient way to collaborate with authors from other groups / institutions easily. It allows for nice and easy WYSIWYG reviewing and you can export the final document as a git to store it on your local git server, if you want to do so, e.g., for archiving purposes. Should you mostly find time to work on documents while you don’t have Internet access, Overleaf may not be the best solution.

Posted on

All this silence

I just realized how silent I was on my website over the last almost 1.5 years. I decided that I should change that.

As a first follow-up on my article about the Opera tab manager: in some of the Opera versions after my write up, the team actually included a way to search tabs in a much nicer way than the plugin allows.

Given my, maybe weird, control setup for tab handling – Left_Alt + one_of(h,j,k,l) – I was happy that they set the shortcut to Left_Alt + Space by default. This opens the Opera quick search.

The quick search is an overlay that allows you to (1) search Google, and, more importantly for me, (2) search your tabs! This is great news for me, and, I would assume, for everybody who constantly carries around a larger bag full of open tabs. I really enjoy this feature as it nicely blends into my general browser setup. It feels also much more responsive and integrated into the browser compared to the plugin.

On another note: I have been following the Vivaldi development quite closely and think that it is a browser that you should follow and test every now and then. It does lack a little bit of performance from the UI compared to Opera or Chrome, but it has some nice features, like tab hibernation or tab stacks.

I also realize that I should write more articles here about the stuff that I do. And I will!

If you are interested you can also follow me on Twitter: @jplehr

Posted on

Keyboard layout and key mappings

When I switched to i3wm as my main work-horse window manager, I decided to use the “Alt Gr” or “Alt_R” key as the modifier key used for the i3 command shortcuts. The main reason for that comes from my habits to mainly work on workspaces 1 – 5. In order to decrease the stress on my left hand, the modifier should be one key that is controlled by the right hand.

First of all, I had to teach the US layout that the both Alt keys were actually different modifier keys. For this purpose I simply use the xmodmap command:

xmodmap -e 'remove Mod1 = Alt_R'
xmodmap -e 'add Mod3 = Alt_R'

In addition of selecting the “Mod3” key in the i3 config of course. This was working fine as long as I used th US keyboard layout.

Since working at a German university requires some interaction in German from time to time, I had to also have a German keyboard layout available. A short search in the web lead to the suggestion so use the simple setxkbmap command with the desired keyboard layout as follows:

setxkbmap de # For the German keyboard layout
setxbkmap us # For the US keyboard layout

So far so good. I change to the German keyboard layout and received an error message on the console saying that it could not remove the binding of the “Alt_R” symbol as no such mapping exists. I did not pay too much attention to that until I realized that I was unable to control my window manager anymore.

After a little while I finally found out that the “Alt Gr” key is mapped to something called “ISO_Level_3_shift_modifier” in certain keyboard mappings, e.g. the German keyboard mapping. After that I did invest quite some time in trying to figure out how I can resolve that problem and get a fully working German keyboard layout.

I then came across this great article , which explains (for me sufficiently detailed) how the key mapping is done. I was then able to adapt my simple commands to change between keyboard layouts to somewhat more lengthy one:

setxkbmap us; xmodmap -e 'remove Mod1 = Alt_R'; xmodmap -e 'add Mod3 = Alt_R' # For the US layout
setxkbmap de; xmodmap -e 'keycode 108 = Alt_R'; xmodmap -e 'add Mod3 = Alt_R'; xmodmap -e 'keycode 133 = ISO_Level3_Shift' # For the German layout

The additional command for the German keyboard maps the “super” or “Windows” key to the former “Alt Gr” functionality – that is the “ISO_Level_3_shift_modifier”. This is necessary, as on a German keyboard, for example, the ‘@’ sign is placed as a third modifier symbol. Thus, without this functionality available it would be a little less convenient.

Posted on

Opera Tab-Manager

After looking for some extension to cope with many open tabs within Opera, I finally found Josh Perry’s TabManager for Chrome. While it allowed to search in the title text of the tabs for specific words, it did move the found tab to a new window and did do a full string search.

However, I think it would be more useful if the found tab is focused instead of moved to a new window, I changed the behavior. In addition, I changed the search behavior to search for all words within the substrings of the tab title. I now decided to fork the original repository and commit my changes, so that maybe other people can benefit from it or improve it further.

You can find the TabManager at my fork of the original repository.

Posted on

Other “mes”

In case you are interested in checking out what I do, you can visit two other places:

Currently I am doing some code clean-up on a small library that I implemented around the PAPI library. I used my library in a paper that I published and think it should be available for reference. However, I don’t know when it will become publicly available.