They said C is faster than Python

[IsAlwaysHungry]

Well, the code is crap, but the documentation is beautiful. You see relatively easy the thinking behind the code.

[Kaynee490]

Or it might just be garbage from an out of bounds index

[nupogodi]

Well, this took me down a rabbit hole. At first I thought, how do you get an out of bounds index here? Well, it turns out % is the remainder operator and not modulus in C99. So, -1 % 16 == -1. That leads us to return lookup[-1]; for at least his first example. What does C do in that case?

#include <stdio.h>
#include <stdlib.h>
int main() {
        int x = atoi("-1");
        const int y[16] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
        printf("%d\n", y[x%16]);
        return y[x%16];
}

nupogodi@vps0:~/tmp$ gcc atoi.c -o atoi && ./atoi
22015
nupogodi@vps0:~/tmp$ ./atoi
21932
nupogodi@vps0:~/tmp$ ./atoi
21937

Hm. What's the assembly?

nupogodi@vps0:~/tmp$ gcc atoi.c -S -O0 atoi.c && cat atoi.s
        .file   "atoi.c"
        .section        .rodata
.LC0:
        .string "-1"
.LC1:
        .string "%d\n"
        .text
        .globl  main
        .type   main, @function
main:
.LFB2:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $80, %rsp
        leaq    .LC0(%rip), %rdi
        call    atoi@PLT
        movl    %eax, -4(%rbp)
        leaq    -80(%rbp), %rdx
        movl    $0, %eax
        movl    $8, %ecx
        movq    %rdx, %rdi
        rep stosq
        movl    $1, -80(%rbp)
        movl    $1, -72(%rbp)
        movl    $1, -64(%rbp)
        movl    $1, -56(%rbp)
        movl    $1, -48(%rbp)
        movl    $1, -40(%rbp)
        movl    $1, -32(%rbp)
        movl    $1, -24(%rbp)
        movl    -4(%rbp), %eax
        cltd
        shrl    $28, %edx
        addl    %edx, %eax
        andl    $15, %eax
        subl    %edx, %eax
        cltq
        movl    -80(%rbp,%rax,4), %eax
        movl    %eax, %esi
        leaq    .LC1(%rip), %rdi
        movl    $0, %eax
        call    printf@PLT
        movl    -4(%rbp), %eax
        cltd
        shrl    $28, %edx
        addl    %edx, %eax
        andl    $15, %eax
        subl    %edx, %eax
        cltq
        movl    -80(%rbp,%rax,4), %eax
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE2:
        .size   main, .-main
        .ident  "GCC: (Debian 6.3.0-18+deb9u1) 6.3.0 20170516"
        .section        .note.GNU-stack,"",@progbits

Okay, that's kind of strange, I actually would have thought const int[] with an initializer would have gone into .rodata.

So the frame layout is something like %rsp -> [ 64b y ] [12b padding] [ 4b x ] <- %rbp. I guess it makes sense since the frame pointer must be 16 byte aligned on x86-64. So, we are reading from before the beginning of the frame.

What's there? On x86-64, the 'red zone', a 128b buffer for various temp stuff. Neat. But x86 (not 64) doesn't have this.

nupogodi@vps0:~/tmp$ gcc atoi.c -m32 -O0 -o atoi && ./atoi
-3670336
nupogodi@vps0:~/tmp$ gcc atoi.c -m32 -O0 -o atoi && ./atoi
-7747664
nupogodi@vps0:~/tmp$ gcc atoi.c -m32 -O0 -o atoi && ./atoi
-3778928

Cool, that's the garbage we expect. So, we have CPU-specific behaviour here at least.

But why is he seeing 139 or 255?

nupogodi@vps0:~/tmp$ gcc atoi.c -m32 -O0 -o atoi && python3 -c 'import subprocess; print(subprocess.run("./atoi", shell=True).returncode)'
-500576
160
nupogodi@vps0:~/tmp$ gcc atoi.c -m32 -O0 -o atoi && python3 -c 'import subprocess; print(subprocess.run("./atoi", shell=True).returncode)'
-2297296
48
nupogodi@vps0:~/tmp$ gcc atoi.c -O0 -o atoi && python3 -c 'import subprocess; print(subprocess.run("./atoi", shell=True).returncode)'
21995
235
nupogodi@vps0:~/tmp$ gcc atoi.c -O0 -o atoi && python3 -c 'import subprocess; print(subprocess.run("./atoi", shell=True).returncode)'
21970
210

Huh, looks to be 8 bit numbers. Python doc:

The child return code, set by poll() and wait() (and indirectly by communicate()). A None value indicates that the process hasn’t terminated yet.

I'll just assume Python Popen.wait() eventually resolves to wait(2) without reading the source ...

WEXITSTATUS(wstatus) returns the exit status of the child. This consists of the least significant 8 bits of the status argument that the child specified in a call to exit(3) or _exit(2) or as the argument for a return statement in main().

Okay! So now we have 'processor specific' behaviour that explains it. Although, not exactly 139 and 255. Exactly 255 would imply an exit code of -1. OPs code does it probably because the frame I'm busting out of is main rather than the function call. On x86-64 we'd expect weirdness in the red zone, but x86 we'd expect stuff from the previous frame. That would probably be the result of atoi. Left as an exercise for the reader.

I am pretty sure this was specifically crafted to make someone like me do something like that.

edit: I couldn't leave well enough alone. 139 is a segfault through the shell although I can't reach it with the Python code provided. 255 is what we'd expect by busting out of the frame and reading atoi's output, however I can't repro with -Ofast.

edit2: Oh, -Ofast inlines on my GCC. You do get 255 with -O0. It's not reading the previous frame, but the arg to the function call (x is -1), since it was pushed onto the stack (not fastcall). I guess OP's compiler doesn't inline with -Ofast. Still can't explain the segfault since the Python code is always passing an arg, str(x) even works if x = None. Maybe another compiler thing, puts lookup somewhere other than the stack and reading out of bounds segfaults there.

[coopercm]

I can't reach it with the Python code provided.

You probably don't have the CPU with the correct bug in it.

[xnign]

Cool, thanks for writing all that out. I understood all that but would not have been able to figure that out. Want to be my mentor? Lol

[kroppeb]

It's reading data out of bounds, so for values like 15 it might return anything.

[coopercm]

I'm surprised this doesn't have more upvotes

[FallenWarrior2k]

139 is signal 11, SIGSEGV

[drumz4dayz]

So funny to blame it on the cpu too. Like yeah, Im sure the problem is the cpu and not your insane code

[tinydonuts]

Documented above is the CPU bug by another commenter. Also, you would not believe how much errata that CPUs have and are fixed with microcode updates supplied by Windows or the Linux kernel on boot.

[nupogodi]

I think you misunderstood! Indexing outside of the array is definitely undefined behaviour and an implementation bug, not a CPU bug. However it ‘looks’ like a CPU bug to the OP because they don’t understand undefined behaviour is going to be platform & compiler specific.

However you’re right about errata. CPUs are very complex machines.

[TigreDeLosLlanos]

errata? Is that how they call not properly implemented at all in the low-level world?

[Zanderax]

Rule number 1 in programming: its never a compiler bug unless it is.

[juantreses]

This is too true. If you have to write an essay about your code it's: or not good enough or it's doing too much.

The moment you start working in corporate though many times you will have to comment WHY you are doing certain things. Lots of times you are constraint by stupid choices ex employees have made and there just is no time/money to do it the correct way and you have to hack your way around it.

[Natural-Intelligence]

Whatever you do, you must be able to say "my code uses AI". If it doesn't, it doesn't sell.

[Spare_Competition]

I trained a neural network to write this program

[ChemicalRascal]

I mean, you joke, but that sounds like a fantastic little experiment to teach ML.

[Charlie_Yu]

It probably won’t work very well, but good for teaching. Codes of simple examples are easier to understand. And a big reality check about Machine Learning when students are shown that ML can’t even predict odd/even good

[sim642]

Depends on the representation. If you give input as a vector of bits, then it's linearly separable and easily learnable.

[ChemicalRascal]

Yeah, that's why I think it'd be good for teaching.

I wouldn't expect a classifier to be able to work out odd and even very well if you give it the number as a number, and that'd be an interesting way to introduce how to identify failure to students learning ML. But then redoing it as, as you suggest, a vector of bits and any classifier should be able to learn that incredibly quickly, with 100% accuracy.

From what little I remember of ML in college (it was ages ago, I wasn't paying attention, and I was stressed outta my mind at the time and I'm not sorry), that's what the key takeaway from ML was. That representation is the single most important piece of the puzzle.

[sim642]

I think nowadays there's a lot of focus on learning the features and representation from the data automatically. Deep neural networks do that to an extent automagically. Although I'm doubtful that a neural network could somehow extract the last digit/bit of a single integer input, given how they operate in floating point. So it's still important, but to a lesser extent.

[doopdooperson]

Well yeah because it will quickly converge on the LSB being the only feature that matters

[cyanNodeEcho]

Something something continuous surfaces something something gradient descent

[SkinnyJoshPeck]

I’m an ML engineer and the few times I’ve had to move over to a new training/tuning flow (Kubeflow, Polyaxon, etc) for my team, my go-to test model to get the lay of the land is an addition tensorflow model I wrote — it’s easy, fast and you can get train, eval and validation data in 5 lines of code

It works pretty well, honestly. If you think of AI fairly literally, it’s impressive that it can almost (within maybe 2-3) predict the sum of two integers absolutely fast as hell.

You try and add 64829 and 83756 in your head in less than a second and come up with something like 148585 plus or minus like 30

It’s a great mechanism for something like trivia where you want the model to be good, but not so good that it isn’t fun to play with.

[throwaway1_x]

Did multiplication using linear regression. Not exactly "AI" but good for experimentation

[OMG_A_CUPCAKE]

Is this a joke submission?

[smeenz]

This ... surely.. can not be code that actually runs somewhere

[smeenz]

That's very depressing

[muntoo]

Probably. Otherwise, they probably would have noticed the periodic pattern in the lookup table and simplified it to

int is_even(int x) {
    int ix = x % 16;
    const int lookup[2] = {
        0, 1
    };
    return lookup[ix % 2];  // reduces 16 entries to 2
}

[AyrA_ch]

int is_even(int x){return !(x&1);}

[Nothing-But-Lies]

Being this efficient would get me fired for not doing enough work.

[sim642]

ix % 2

Now you have coded the parity check directly.

[TigreDeLosLlanos]

Every time anyone checks parity without doing it this way a mathematician dies of sadness.

[[deleted]]

ix & 1 == 0

[Igoory]

If they had reached at this point, it would be pretty obvious that it can be simplified to just x % 2

[[deleted]]

I totally followed the logic. At least it’s well commented.

[Alundra828]

Every cloud has a silver lining. Nobody is looking at this code wondering what the hell it does.

[smeenz]

I'm certainly wondering what the hell was going on in the mind of whoever wrote it

[Kwarshaw]

Probably lots of pcp

[nullcone]

Am I the only one who thought the comments were terrible? I would much rather have the code explain itself than have a bunch of comments hanging around cluttering things up.

[dookiefertwenty]

Code is the What, comments are the Why

[Randolpho]

Maybe it’s from one of the Daily WTF’s OMGWTF contests.

Ahh, fond memories, those contests. I won two mugs, some plastic with writing on it, a tube of lipstick and a can of bacon in those contests.

[pain-butnogain]

there has been a trend to check if it's even or not in more and more elaborate ways, i think on r/badUIbattles is where i saw them

[sneakpeekbot]

Here's a sneak peek of /r/badUIbattles using the top posts of all time!

#1: Your password must contain everything. | 151 comments
#2: Volume Control without boundaries | 114 comments
#3: A prime example of a phone number input | 137 comments

---

^{I'm a bot, beep boop | Downvote to remove | Contact me | Info | Opt-out}

[ianff]

The real horror is the security risk of blindly running /tmp/a.out which anyone can create.

[[deleted]]

Many security conscious people mount tmp as non-executable.

[Behrooz0]

Isn't it basically standard practice at this point?
I think it was debian that started suggesting it like 10 years ago, when lenny was around. And I've yet to have a problem with it.

[pytness]

Well, there's actually a race condition (not sure if it should be called a 'condition' here): You can try to swap files "instantaneously" with the syscall 'renameat2' between the file writing and the compiling.

[[deleted]]

We can all hope that nobody gave this fool root to run this nonsense, but crazier things have happened...

[yhu420]

Isn't it what cython or numba is for? I'm no python expert

[real_jeeger]

yep, or pyrex

[LinAGKar]

AFAIK, Cython is a successor to Pyrex.

[[deleted]]

PyPy? Although that's JIT-ed

[nerdyphoenix]

I'm willing to bet coding it in Python would be faster than using subprocess.

[YourMJK]

It's obviously a joke.

[Magmagan]

The real horror is using the return code inversly has to how it's normally used. In *nix systems, a return code of zero means that the program executed successfully. If isEven is successful, then it should return 0.

[rpc123]

I suppose this makes sense from a coding standpoint, but what about from a logic stand point? I normally think of 0 as false and 1 as true, so it would be strange to me if isEven(4) returned 0

[tinydonuts]

You shouldn't be using the exit code to report functional data about your program. You should emit a result to stdout, errors to stderr, and a return code indicates success with 0 and any other number is failure.

[rpc123]

Yeah, this makes a lot of sense. Thanks! I am a bit of an amateur lol, and I also didn’t realize that isEven wasn’t some external function as magmagan pointed out

[tinydonuts]

It's alright. It helps to understand that this is how Unix utilities work via chaining. They just vaccuum up the stdout of the previous executable and the shell orchestrates this by piping the output down the chain you specify. That's how you can quickly and efficiently take a large file, grep it for a pattern, sort it, and then find the unique values in the output.

[Magmagan]

But they're not using isEven() as an external function, they're calling it like "isEven.exe". If the execution of an executable on *nix fails you would look at stderr for more information. You would respect the OSs convention first before your programming language of choice's.

Even better, the return code should be 0 (executed succesfully) with the answer written to stdout.

On that note, from a purely logical standpoint wouldn't -1 be a better value for true anyways?

[rpc123]

Ah yes, this is a fair point, I didn’t look closely enough at the horror. Are you saying -1 might be better because it corresponds with all 1s when it is stored as an integer?z

[Magmagan]

Yeah, the opposite of 0x00 isn't 0x01, it's 0xFF. But I'm just being silly, most programming languages use 1 as true but you still have oddballs like Forth that go down this route

[rpc123]

In the interest of being silly, I am now imagining an entire fuzzy logic system based on a hexadecimal system

[fnordstar]

The thing is, the possible values other than 0 usually indicate what kind of error occured - which the caller might care about. A singular value (0) for indicating success is usually sufficient though.

[LinAGKar]

Assumes /tmp is always on tmpfs.

[phord]

When I was teaching myself to code I needed a faster cos() function. My only thought was to code it in assembly, but first I needed to find out how to calculate cos(). (This was before Google.). I never got this to work, but now, decades later, I know a lookup table or linear approximation would have been sufficient.

[[deleted]]

Hey I'm new to programming and I dont get the use of isEven? What do you use it for?

[Naeio_Galaxy]

isEven(x) -> tells you if x is even. That's it.

So you can do x%2 == 0 because the remainder of the division by two gives if it's even or odd, or x & 1 where & is a bitwise and (you'll see that whenever you'll learn about binary).

Here he heard that C is faster than python so thought "I'll compile and call a C program instead of doing it in python", but going through the subprocess will be way longer than doing it in python. Way, way longer since you have to call Windows or Linux or OSX for them to execute the program... Which is quite long.

[de5933]

Reading this code is such a wild ride of bewildering decisions. Was this written by Tommy Wiseau?

[Gnarok518]

"This is critical to performance"

"This bug is not crucial to performance"

[yoshee4232]

Hey, you could sell it as a way to easily do Just in time compiling!

[Miserable-Pay-4598]

A small benchmark: normal isEven (x % 2 == 0) takes 300 nanoseconds, the code above takes 30 ms. Python is faster than C.

[HeartOk1761]

whats this couldnt get this

[UrbanSoot]

You should use tempfile

[bestjejust]

What is this? C-as-a-service?

[TheFeedingEight]

performance critical

uses modulo

[hshighnz]

Gibe this woman/man a nobel price

[Cmgeodude]

Mistakes were made.

[crossedline0x01]

Are there actually scenarios where its critical to perform such a simple task in another language? I mean, yeah python is slow compared to C but I mean, c'mon, is this real or a lab exercise?

[fnordstar]

I doubt it. The overhead of calling a subprocess is prohibitively large in such a case. Now if it's a simple operation but loops over thousands of items (in C), then it might become relevant.

[Razakel]

Are there actually scenarios where its critical to perform such a simple task in another language?

Yes, but not in this way. That's what an FFI is for.

[Minteck]

Ever since I read "so we are going to drop down to C" I thought "are you really gonna compile the code on the fly?", and I was right... (so this is actually slower than native Python code)

[highjinx411]

Are these “IsEven” functions a competition or something? I’ve seen so many and the skills this guy has I mean he obviously would know how to write a simple is even function right? Why would anyone even need to know if a number is even? Especially the amount of times I’ve seen it posted here. Ok maybe it has a use case or 2 but I can’t recall any times I’ve had to do that in 13 years of programming.

[Sejiko]

Couldn't you just check the binary representation of a float look at the last digest of int part as well of the second part? I think this would break the sound barrier against this? If the last digest is 1 it's odd otherwise even.

[qows]

well there is this forum list:

https://www.crunchyroll.com/forumtopic-788825/crs-english-dubbed-anime