clausecker · HackerTrans

clausecker

335 karmajoined 3 jaar geleden

Submissions

Hacking Washing Machines [video]

media.ccc.de

222 pointsby clausecker7 maanden geleden49 comments

Prepare(): a new API proposal for process creation

gist.github.com

3 pointsby clauseckervorig jaar1 comments

Sneak Peek: SIMD-Enhanced String Functions for AMD64

freebsdfoundation.org

2 pointsby clausecker3 jaar geleden0 comments

comments

7 dagen geledendiscuss

Isn't the conjecture proved for two dimensions?

3 maanden geledendiscuss

Go had panic/recover right from the get go. Nobody “caved.” And indeed, you are free to use panic/recover for error handling in your code. That was always allowed.

That said, the key insight of the exception craze is that error returns are a normal part of a functions behaviour and as such should not use extraordinary control flow to take place.

Exceptions (panics) are used for things that should never happen or are indicative of a programmer error, like nil dereferences or out-of-bounds array accesses. That is, things where the programmer is not expected to provide reasonable behaviour on the API level if it happens (but perhaps there is a whole-program fault handler to shut down cleanly).

Opening a file that does not exist? Database record not found? Invalid credentials? These should be anticipated by the programmer and can occur at any time. Not exceptions, normal return values. Go requests that you think about these possibilities instead of pretending they can be ignored.

3 maanden geledendiscuss

Really bad idea.

Silently returning some (the wrong) value is always worse than catching the error right then and their and panicking. A panic is a noticeable symptom of something just having go wrong that is easy to chase after and debug. A silently returned wrong value just causes data corruption down the line, at great pain. It is very annoying to debug, in particular if people start to some times rely on this behaviour as an intentional part of their data flow.

3 maanden geledendiscuss

> No it really doesn't. It litters your code with if statements that are all just about the same, except that one that needs to be different, and you go blind looking at them all and can't spot the difference.

If most of your error handling is just bubbling the error up, you are doing something wrong.

  if err != nil { return err; }

is an antipattern. Not because it's verbose, but because you are supposed to handle the error, not pass it right through, in most cases.

7 maanden geledendiscuss

You can find the first set bit in an integer with a machine instruction, it's completely branch free. gcc has __builtin_ctz() for this. You'll either need to iterate over all set bits (so one branch per set bit) or use a compression instruction (requiring AVX-512) to turn the bit set into a set of integers.

That said, as you seem to actually want to do something with the results, you'll take a branch per match anyway, so I don't see the problem.

7 maanden geledendiscuss

So I've thought about it and I don't really feel like spending more time to convince you that this works. If you have questions I am happy to answer them, but please write your own code.

7 maanden geledendiscuss

This does track the state. If you want to track it across multple vectors of input, you'll need to carry it over manually.

7 maanden geledendiscuss

You can do it like this, assuming A is the mask of newlines and B is the mask of non-spaces.

1. Compute M1 = ~A & ~B, which is the mask of all spaces that are not newlines 2. Compute M2 = M1 + (A << 1) + 1, which is the first non-space or newline after each newline and then additional bits behind each such newline. 3. Compute M3 = M2 & ~M1, which removes the junk bits, leaving only the first match in each section

Here is what it looks like:

    10010000 = A
    01100110 = B
    00001001 = M1 = ~A & ~B
    00101010 = M2 = M1 + (A << 1) + 1
    00100010 = M3 = M2 & ~M1

Note that this code treats newlines as non-spaces, meaning if a line comprises only spaces, the terminating NL character is returned. You can have it treat newlines as spaces (meaning a line of all spaces is not a match) by computing M4 = M3 & ~A.

7 maanden geledendiscuss

We do this with FreeBSD ports, but users don't have to clone the ports tree unless they want to modify ports or compile them with custom options.

8 maanden geledendiscuss

And the same reason NVRAM was dead on arrival. No affordable dev systems meant that only enterprise software supported it.

8 maanden geledendiscuss

That's more "load store architecture" than RISC. And by that measure, S/360 could be considered a RISC.

8 maanden geledendiscuss

You may enjoy the RISC deprogrammer: https://blog.erratasec.com/2022/10/the-risc-deprogrammer.htm...

8 maanden geledendiscuss

FreeBSD

8 maanden geledendiscuss

ARM already has most stuff required for this on board. Two proprietary extensions are used by Rosetta: one emulates the parity (rarely used) and half-carry (obsolete) flags, which can also be emulated conventionally. The other implementa TSO memory ordering, which can either be ignored or implemented with explicit barriers; some other chips apparently have a similar setting.

The other stuff is all present in ARMv8.5 I think.

9 maanden geledendiscuss

It's very likely that there is some serious autovectorisation going on behind the scenes.

9 maanden geledendiscuss

Best one was when gedit had the option to syntax highlight for a language named “Los.”

9 maanden geledendiscuss

Had the same feeling browsing through the Haskell package collection. Felt like and almagamation of PhD theses, none of which were maintained after the author got his degree. Every single one a work of art, but most engeneered so badly that you would only use them begrudgingly.

9 maanden geledendiscuss

Such as?

10 maanden geledendiscuss

I'm talking about how they are able to integrate stuff that normally wouldn't fit into 32 bits (such as 3 operand simd with masking), not about getting the instruction set more compact. ARM knows how to do this (Thumb being the most compact mainstream ISA is evidence of that), they just have decided to waste a bit more space to make decoding simpler, while also adding more quality-of-life features.

10 maanden geledendiscuss

Also, the VAX instruction encoding is a class of horror above that of x86.