Just how expensive is slub_deug=p?

Recently, I became interested in a debugging option in the Linux kernel

slub_debug=p

Average Half load -j 2 Run (std deviation):
Elapsed Time 44.586 (1.67125)
User Time 73.874 (2.51294)
System Time 7.756 (0.741741)
Percent CPU 182.4 (0.547723)
Context Switches 13880.8 (157.161)
Sleeps 15745.2 (24.3146)

Average Optimal load -j 4 Run (std deviation):
Elapsed Time 32.702 (0.400087)
User Time 89.22 (16.3062)
System Time 8.945 (1.37014)
Percent CPU 266.4 (88.5729)
Context Switches 15701 (1929.57)
Sleeps 15722.2 (78.1875)

without slub_debug=p

Average Half load -j 2 Run (std deviation):
Elapsed Time 40.614 (0.232873)
User Time 69.978 (0.503061)
System Time 5.09 (0.182209)
Percent CPU 184.4 (0.547723)
Context Switches 13596 (121.501)
Sleeps 15740.4 (46.4629)

Average Optimal load -j 4 Run (std deviation):
Elapsed Time 30.622 (0.171523)
User Time 86.233 (17.1381)
System Time 5.874 (0.853557)
Percent CPU 270.1 (90.3431)
Context Switches 15370.3 (1875.97)
Sleeps 15777.4 (74.43)

Manage passwords without state

A few years ago I had a problem: I had a bunch of accounts that I accessed once a year when tax time came around, and I kept forgetting the passwords. Often I'd try a few before locking myself out, and then I'd have to spend an hour on the phone with customer service getting my account unlocked, which meant if I was doing my taxes on the last weekend possible, I wouldn't be able to complete them until the next business day. The obvious solution to this problem is to store the passwords in some kind of password manager -- lots of them exist for all kinds of platforms: phone, computer, browser, etc.

The problem with password manager is that they typically require some kind of state file. They store the mapping between site and cleartext password in some file, and then they decrypt it with some secret from you when you want to access it. Thus, you have to 1. trust the person who is doing the encrypting and decrypting that they are doing it correctly so that when your laptop gets stolen your passwords aren't leaked, and 2. you have to have access to the machine that the passwords are stored on when you want to use them. If you've left your laptop at home or you forgot to back up your password file when you got a new computer, you're SOL.

What's the solution? A password manager without state, of course! Since we're assuming the user can remember at least one pretty good password, we can use that as our "state", so we end up with the algorithm as follows:

hash = sha512(user_secret + "example.org")
base64encode(hash)[:10]

Here, we're using the domain to salt the user secret so the generated passwords are different for each site. sha512 provides randomness, although we are only using the first 60 bits of the output here (10 base64 characters, each character encodes six bits of entropy), there are significantly more bits of entropy here than in your typical English character, making it a much stronger password. Further, the algorithm is very simple, and you could re-implement it on any computer that has your favorite programming language environment available. Thus, you can use it in a pinch, since all you need to remember are the algorithm and your user_secret. I've published a python script that implements this mechanism, so you don't even have to remember the algorithm