Eli Bendersky's website - Hardware & Gadgets

Replacing my home desktop computer

2022-11-02T20:31:00-07:00

After 9 years, it's time to retire my old and faithful home Linux machine. It has served me extremely well, by far the longest time I've used a home computer without any replacements. The fans were starting to show their age, to the extent that the CPU fan sometimes needs a nudge to start after the machine has been off. While this can be fixed, I also wanted a somewhat faster machine with more memory.

I've long been keeping a curious eye on system76; they build and sell HW that was designed for Linux from the start. While my old machine - which was just a custom build - handled Linux fine over the years, it did exhibit some snags here and there (Bluetooth, for example). It would be nice not to deal with this and have HW that just works.

So I went ahead and ordered a "Meerkat" model, which is a really tiny 4.5"x4.5" box (with a comically large power adapter) that manages to pack 32 GiB of memory, a sizable SSD and a 4-core (8-thread) i5-1135G7 CPU. It came with Ubuntu 22.04 preinstalled and was very quick and easy to set up. I moved all my daily operations to this machine a couple of hours after unpacking it. Just the computer itself changed - it's still the same monitor, keyboard and mouse. I could finally use my Bluetooth earphones with it, without any issues.

It's about 33% faster than my older machine (at least for compiling the Go toolchain and medium-sized Rust projects), and it's nice to have twice as much memory and a larger SSD. I'm quite happy with it so far. It's not the cheapest option out there, but it is a "pay for high quality with minimum fuss" option.

Update 2024.11.02: I replaced this computer after two years. It's still working great, but was becoming a bit underpowered for my needs, especially because it lacks a GPU. Being pretty happy with System76, I went for a Thelio Mira with an i7-13700K CPI (16 Cores - 24 Threads 8P+8E), 64 GiB of memory and an inexpensive gaming-class Nvidia GPU.

Intel i7 loop performance anomaly

2013-12-03T07:18:48-08:00

Recently I've been doing some benchmarking and came upon a very surprising behavior from a number of different Intel i7 CPUs (it manifests on Sandy Bridge and Haswell desktop-class CPUs as well as Sandy Bridge-EP Xeon CPUs).

The benchmark is very simple and the result is... bizarre. Perhaps one of the readers of my blog knows what's going on here. Here's the C code for the benchmark (full code with a makefile is available in this Gist):

const unsigned N = 400 * 1000 * 1000;

volatile unsigned long long counter = 0;

// Don't inline the benchmarking code into main
void __attribute__((noinline)) tightloop();
void __attribute__((noinline)) loop_with_extra_call();

void tightloop() {
  unsigned j;
  for (j = 0; j < N; ++j) {
    counter += j;
  }
}

void foo() {
}

void loop_with_extra_call() {
  unsigned j;
  for (j = 0; j < N; ++j) {
    __asm__("call foo");
    counter += j;
  }
}

We're benchmarking tightloop vs. loop_with_extra_call, which does exactly the same thing (increment a volatile counter) but has a dummy call to a do-nothing function in the middle. I don't think anyone has doubts about how this should behave, right? How much slower do you think the extra call will make this loop? Twice as slow? 10% slower?

Here's the driving main function:

int main(int argc, char** argv) {
  if (argc <= 1) {
    return 1;
  }

  if (argv[1][0] == 't') {
    tightloop();
  } else if (argv[1][0] == 'c') {
    loop_with_extra_call();
  }

  return 0;
}

Building the code with gcc version 4.8 (same output code is produced by 4.6, as well as when replacing -O2 by -O3):

$ gcc -O2 loop-call-weirdness.c -o build/loop-call-weirdness

Now I'll run it on my Intel i7-4771 (Haswell) CPU. First run the version with tightloop:

$ perf stat -r 10 -e cycles,instructions  build/loop-call-weirdness t

 Performance counter stats for 'build/loop-call-weirdness t' (10 runs):

     2,659,506,002 cycles       #    0.000 GHz              ( +-  0.19% )
     2,401,144,539 instructions #    0.90  insns per cycle  ( +-  0.00% )

       0.685642994 seconds time elapsed                     ( +-  0.24% )

... and with the extra call:

$ perf stat -r 10 -e cycles,instructions  build/loop-call-weirdness c

 Performance counter stats for 'build/loop-call-weirdness c' (10 runs):

     2,336,765,798 cycles       #    0.000 GHz              ( +-  0.34% )
     3,201,055,823 instructions #    1.37  insns per cycle  ( +-  0.00% )

       0.602387097 seconds time elapsed                     ( +-  0.39% )

Yes, the extra call makes the code faster! You didn't expect that, did you.

Looking at the disassembly, the compiler is doing fine here, producing quite expected code:

0000000000400530 <tightloop>:
  400530:     xor    %eax,%eax
  400532:     nopw   0x0(%rax,%rax,1)
  400538:     mov    0x200b01(%rip),%rdx        # 601040 <counter>
  40053f:     add    %rax,%rdx
  400542:     add    $0x1,%rax
  400546:     cmp    $0x17d78400,%rax
  40054c:     mov    %rdx,0x200aed(%rip)        # 601040 <counter>
  400553:     jne    400538 <tightloop+0x8>
  400555:     repz retq
  400557:     nopw   0x0(%rax,%rax,1)

0000000000400560 <foo>:
  400560:     repz retq

0000000000400570 <loop_with_extra_call>:
  400570:     xor    %eax,%eax
  400572:     nopw   0x0(%rax,%rax,1)
  400578:     callq  400560 <foo>
  40057d:     mov    0x200abc(%rip),%rdx        # 601040 <counter>
  400584:     add    %rax,%rdx
  400587:     add    $0x1,%rax
  40058b:     cmp    $0x17d78400,%rax
  400591:     mov    %rdx,0x200aa8(%rip)        # 601040 <counter>
  400598:     jne    400578 <loop_with_extra_call+0x8>
  40059a:     repz retq
  40059c:     nopl   0x0(%rax)

Note that the volatile is key here, since it forces the compiler to produce a load and store from the global on each iteration. Without volatile, the benchmark behaves normally (the extra call makes it significantly slower).

It's easy to see that tightloop runs 6 instructions per iteration, which computes with the numbers reported by perf (400 million iterations, times 6 instructions, is 2.4 billion instructions). loop_with_extra_call adds two more instructions per iteration (the call to foo and the ret from it), and that also corresponds to the performance numbers.

That's right, even though the version with the extra call executes 33% more instructions, it manages to do it quicker.

Unfortunately, my fast Haswell CPU (or the Linux kernel coming with Ubuntu 13.10) doesn't support the whole range of perf stat counters, but running on an older CPU (where the anomaly also exists though the performance difference in smaller), I see that the tightloop benchmark has a lot of frontend and backend stalls (mostly frontend), for a total of 0.92 stalled cycles per instruction. The version with the extra call has just 0.25 stalled cycles per instruction.

So would it be right to assume that the tight loop stalls on loading from counter because the rest of the instructions in the loop depend on its value? So how does the call and ret help here? By providing non-data-dependent instructions that can be run in parallel while the others are stalled? Still, whatever that is, I find this result astonishing.

Let me know if you have any insights.

A new Ubuntu machine for home

2013-11-23T14:29:13-08:00

Update (2022-11-02): 9 years later, this machine has been replaced.

This week I got a new machine for my home workstation. My previous machine was a 3.5-year old Asus laptop running Ubuntu 12.04; while the laptop is relatively powerful (Sandy Bridge i7 2820QM CPU), there were a couple of problems that prompted me to upgrade:

I really wanted to use a high-resolution (WQHD - 2560x1440) screen at home, and the laptop's graphics card (integrated Intel Sandy Bridge graphics) isn't up to the task (its maximal resolution support is 2048x1152).
It was starting to become sluggish for large tasks mainly due to having just 4 GB of memory. For example, I couldn't really run a full LLVM & Clang build with parallelism because linking would take the whole physical memory and the machine would start thrashing. Building LLVM & Clang in a single thread is unbearably slow (above an hour), and splitting the compilation & linkage is cumbersome and slow.

So after some online research I settled on the following setup. Since I really only use this machine at home when sitting behind my desk, I got a desktop because these are cheaper to upgrade, can house more powerful hardware and I didn't really need any laptop features in it.

Screen

Starting with the crown jewel - a Viewsonic VP2770-LED screen. A stunning 27" with 2560x1440 resolution. I got this one before the new hardware, so I could verify that indeed my old laptop can't push the full resolution to it.

This monitor can run in full resolution only from a DP (Display Port) connector or DVI. This was an important consideration in choosing a motherboard.

CPU, memory, motherboard

Relatively high-end Haswell i7-4771 CPU, with 4 cores / 8 threads at 3.5GHz and 8MB of cache. Crucially, it comes with the Intel HD Graphics 4600 on board, which can support WQHD resolution. There's a catch, though. It only supports such resolution with DP or HDMI. Note - not DVI, so the intersection of GPU and monitor leave only DP as a viable option.

For memory, I got 16GB of Corsair Vengeance DDR3. 16GB should be plenty for now.

Motherboard - the main consideration, as mentioned above, is to have a DP output. This is why I got the Asus Q87M, which is a bit higher-end than the minimal motherboard I could get for my setup. It has DP output as well as a bunch of other goodies like two USB 3.0 ports.

Storage

Another minor reason for the upgrade was to move on from a magnetic disk to SSD. For this new setup I got a 250GB Samsung 840 EVO SSD. I was pondering the size I need, but really for anything above the 100-200GB mark that would probably be backup data so I could use my external HDD to supplement that. On the laptop this system is replacing I never went above 200GB total.

Miscellanea

Since I don't have a discrete GPU and the Haswell CPUs are not overly power-hungry, I could get by with a small power supply. So I got a good, quiet Antec 380W supply. As for the case, one of the simpler CoolerMaster ones that promised to be quiet (and indeed it is).

That's it! In 2013 there are no floppy drives, CD/DVD drives, sound cards, external network cards and a bunch of other crud we used to shove into our desktops just a few short years ago. Since my setup uses Intel's integrated graphics, it's super minimal - there are no PCI cards on the motherboard at all.

Software

After a very short consideration I went for the latest and greatest Ubuntu - 13.10.

I'm very impressed with how quick and easy it is to install an Ubuntu desktop these days. It takes considerably less time and effort than it took to install Windows XP, say a couple of years ago. Part of that can be attributed to the speed of the system (the SSD is smoking fast - Ubuntu installed in just a few minutes), lack of external hardware and other stuff. But all in all, it's a pleasant experience to have a quick setup where everything (including the fancy WQHD monitor on a DP connection) just works with almost no tweaking. I was planning to spend the whole weekend on setting this thing up, and ended up doing it in just a couple of hours spread over week-day evenings and mornings.

And of course, one of my favorite parts of the Ubuntu experience is that all the software you need is just a sudo apt-get away. In addition, many desktop programs (like Dropbox and Chrome) just let you download .deb files and install them.

Online support is so much better these days, thanks to Google and Ask Ubuntu. To answer any question (how do I make the mouse faster? what's a good graphical program to show detailed hardware information?), just type it into Google with "ubuntu 13.10" attached and in all likeness the answer is a couple of clicks away. For me, Ubuntu/Linux has been OS of choice of years, but even for the more general public I could agree that 2013 is the year of the Linux desktop, based on my experience. Really, I should probably go order something from Ubuntu's overpriced gift shop just to contribute back :-)

Finally, I can't overestimate the convenience of having all your configuration ("dot-files") in a Git repository so making your system behave just like you other systems is only a git pull and a few soft links away.

Performance

A couple of years ago when LLVM & Clang were much smaller and could still link successfully on my laptop, it took me about 15 minutes for a full build. Today I built them on the new machine in under 10 minutes (9:35) - which is impressive, given how much they grew in these two years. The peak memory usage (with make -j8) climbed to over 6GB, which aligns with my observations of thrashing on the laptop. The full regression suite (check-all) runs in 1:33 minutes, which is pretty good.

CPython builds 40% faster (0:51 vs. 1:30); its full test suite runs 35% faster (1:23 vs. 2:06).

Node.js builds more than twice as fast (0:46 vs. 1:51).

That's about all the benchmarking I intend to do because that's what I ultimately care about - compiling stuff and running tests - for large projects, quickly in parallel.

The SSD adds a lot of snappiness to the system. It boots up very quickly, everything responds immediately. pss / grep searches are super-fast. It's a great new age where HDDs with their horrible seek times can be placed on the shelves of history.

New toys

2012-05-19T13:51:41-07:00

I got a couple of new gadgets/toys recently.

The new iPad - white, 16GB wifi version. It's really sleek - lighter and slimmer than my old iPad (first generation). The branding is confusing, why didn't they just call it iPad 3? The screen is great, but I wonder what would be the killer application to really let it shine? HD movies? Because when just viewing photographs and browsing, there isn't too much difference from the old one's screen.

Kindle touch. I already have a "normal" kindle (also from the new generation), but it's so useful in our family that I wanted another one. This time I bought a touch screen version thinking that it should make dictionary translations easier (for reading in Spanish, etc). I like its controls, but it's somewhat fatter and heavier than the normal Kindle which makes it less convenient for holding. I hope it's not a big difference when I'm actually used to it.

Read It Later - first application bought for my iPad

2010-12-25T10:28:51-08:00

Being a frequent visitor of link-aggregation sites like Proggit and HN, I frequently find myself bookmarking interesting articles for "future read". Previously, I used Xmarks, and later Firefox sync, for keeping these bookmarks synced across machines (I use at least 3 different regularly).

However, with an iPad joining my arsenal of geeky gadgets, I had to find a more complete solution. An iPad is wonderful for reading articles "later" on the couch, reducing total time spent staring at a real computer screen.

After some looking around, I came upon Read It Later - which is a set of tools designed exactly for what I need.

Read It Later (RIL) allows me to do the following:

With a Firefox plugin, I can now save any article I want to read for future reference with a simple keyboard shortcut. Naturally, this article will be available on all computers for which I installed RIL and synced with my account.
An iPad app allows me to immediately be able to read this article on my iPad - even offline.
A bookmarklet for iPad's Safari browser allows me to save articles to read later from the iPad as well.

I played with the free version of the app for a couple of weeks just to make sure that's what I need and then bought the full version. I'm not sure that the full version gives me real benefits over the free one, but it was cheap ($3) and I wanted to have a way to thank the author of RIL for his excellent work.