jne | PHP HTTP client library for checking JNE shipment prices | REST library

The slow version:

Note that the sub rax, 1 \ jne pair goes right across the boundary of the ..80 (which is a 32byte boundary). This is one of the cases mentioned in Intels document regarding this issue namely as this diagram:

So this op/branch pair is affected by the fix for the JCC erratum (which would cause it to not be cached in the µop cache). I'm not sure if that is the reason, there are other things at play too, but it's a thing.

In the fast version, the branch is not "touching" a 32byte boundary, so it is not affected.

There may be other effects that apply. Still due to crossing a 32byte boundary, in the slow case the loop is spread across 2 chunks in the µop cache, even without the fix for JCC erratum that may cause it to run at 2 cycles per iteration if the loop cannot execute from the Loop Stream Detector (which is disabled on some processors by an other fix for an other erratum, SKL150). See eg this answer about loop performance.

To address the various comments saying they cannot reproduce this, yes there are various ways that could happen:

• Whichever effect was responsible for the slowdown, it is likely caused by the exact placement of the op/branch pair across a 32byte boundary, which happened by pure accident. Compiling from source is unlikely to reproduce the same circumstances, unless you use the same compiler with the same setup as was used by the original poster.
• Even using the same binary, regardless of which of the effects is responsible, the weird effect would only happen on particular processors.

From past experience doing this sort of thing, a process of successive refinement is in order. so first write it like fortran:

The instruction JG is for comparision of signed integers. A 8-bit value 255 means -1 in two's complement and the jump is taken because 2 is larger than -1.

You should use JA to compare unsigned integers and jump in greater case.

Reference: Intel x86 JUMP quick reference

This makes the output of the program EOOOO instead of EOOOE.

You seem not to be fully aware what the following instructions in your code actually do:

In x86 assembler two values in memory are swapped simply by

You didn't reserve enough temporary storage for the input/output string.
name db 0xa defines room for only one byte, and to no effect initializes it with the value 0xa. This value is overwritten by the first letter in GET_STRING name, 101. The next letters are stored to the undefined memory which follows behind the name. Memory allocated for section .data is rounded up, so several bytes may have been allocated behind the name byte and your program by accident works for short input strings. When the string is longer, it will try to access unallocated memory, which leads to segmentation fault.

Omit , 0xa from output string definition and replace name db 0xa with
name: times 101 db 0x0a , see repeating Data in NASM
You can print output together with name as a one concatenated string.

I thought my compiler is smart enough to align the code correctly.

As you said, the compiler is always aligning things to a multiple of 16 bytes. This probably does account for the direct effects of alignment. But there are limits to the "smartness" of the compiler.

Besides alignment, code placement has indirect performance effects as well, because of cache associativity. If there is too much contention for the few cache lines that can map to this address, performance will suffer. Moving to an address with less contention makes the problem go away.

The compiler may be smart enough to handle cache contention effects as well, but only IF you turn on profile-guided optimization. The interactions are far too complex to predict in a reasonable amount of work; it is much easier to watch for cache conflicts by actually running the program and that's what PGO does.

the problem with this code is that only one board can move at a time and i need both

The sense of simultaneousness comes from being fast, real fast. Most everything in your computer works serially but we percieve many things as happening in parallel.

Your checkskey code is fine. One board uses the q and s keys, and the other board uses the up and down keys.
As soon as a key is available, the Keyboard BIOS function 00h will retrieve it immediately and your program will update the graphics accordingly. But if your graphical output routines take too long, then the players will start thinking that the keyboard is sluggish.

Looking at your graphics routines, I see that you use the Video BIOS function 0Ch to put pixels on the screen. This is slow and especially painful since you're playing on the easiest of graphics screen where you can just MOV a byte to draw a pixel.

In a program that needs fast graphics it can be very advantageous to have the ES segment register point at the video buffer permanently.

The movslq you see is actually the MOVSX instruction, which in AT&T syntax is called MOVSLQ (yeah, silly, I know). You have the suffixes l (long = 4 bytes) and q (quadruple = 8 bytes) to indicate the size of the two operands. This is a simple move with sign extension from a smaller to a bigger register (in your case EAX to RCX).

The jumps are a little bit convoluted, but you can translate the assembly into pseudo-C code like this: