RVA | Reservoir Visualization and Analysis | Data Visualization library

As usual, yet another missed optimization in the JIT. Report it to the developers of whichever JIT you're using (presumably Microsoft), especially if it comes up in real use-cases. But probably they tuned their JIT this way on purpose, presumably because it's not super common for real code to have such useless if statements. Certainly happens, but most ifs aren't useless.

The general answer to this and your previous questions (about optimizations that C compilers find but C# doesn't) is that JITs have to compile fast, and don't have the time to search for as many optimizations, so you should expect crap like this.

Why 5? Compilers frequently use heuristics on code-size or maybe number of branches to make decisions, perhaps in this case whether to try looking for some commonality between branch paths. In your case, 5 if statements was enough to push past some threshold for some heuristic. If you were investigating an open-source JIT, you could if you wanted dig in and find out specifically where in the source code it made the decision.

Especially for a JIT where compile-time more directly trades off against quality of optimization, skipping a pass that checks for that could make sense. But it doesn't for ahead-of-time C compilers; if you tell them to optimize, they will.

So anything that MSVC can optimize but C# doesn't is likely just a heuristic choice made to keep the JIT fast. IDK if MSVC is a good benchmark, but it's not the most aggressive or good optimizing compiler, compared to GCC and clang.

As @PMF mentioned in comments, this is actually an optimization the C# compiler proper could have made in the IL, instead of leaving it for the JIT. But probably most cases where it happens in real programs (that aren't on purpose written redundantly), it's only visible after things like inlining.

Still, this would be one way for MS to implement an optimization (that works for this intentionally-redundant case) without hurting the JIT-time vs. asm-speed tradeoff.

This is because RecyclerView does not create views for all of your items in the list it create enough ViewHolder to fill up the screen and few more and when you scroll the old ViewHolder are bind to some other data in the adapter that is when the onBindViewHolder() is called , so basically what is happening here is you are setting the background of current ViewHolder on the screen and when you scroll the same ViewHolder in bind to the new data.

I think you have to check in the onBindViewHolder whether or not this is the item to which you want to set the background and then take the decision remove it if the item is not selected in the dataset set background if it is selected.

Avx.IsSupported is a run-time feature because it needs to dynamically detect the capabilities of the target CPU where your code is actually being run.

On the other hand, #if is a compile-time feature, conditional compilation. It's not really useful to have an AVX conditional compilation symbol and then just presume for the target CPU to do have support for AVX. It is simply better to check on run-time and behave accordingly.

However, should you really need to use conditional compilation, you can always declare your own symbol.

Just input

There's a couple of issues.

The first is that scipi.io.wavefile.write() only writes an uncompressed WAV file (ref: https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html ). You might name it .mp3, but it's not compressed that way.

The next issue is that pygame.mixer.music will not .load() uncompressed WAV files. So... what to do...

One work-around is to use the base pygame.mixer, which is happy to load uncompressed WAV. And while I don't have an 'CABLE Input (VB-Audio Virtual Cable)' device, I do get a nice file of silence, which I validated with the sound-editing program Audacity, and this seems to play OK.

There are a number of issues here. The fact that you say this code runs on wine suggests that wine is very forgiving. Windows? Not so much.

To start with, here's the build command I'm using (based on OP's original code above): nasm.exe org.asm -o org.exe

Using dumpbin (from VS2019) against org.exe gives us:

Try to set height of recycler view 0dp and bottom to top of buttons or editext like this:

@user2426998 - you've clearly got bigger problems than loading the wrong .dll.

SUGGESTIONS:

1. Please update your post and explain what you're trying to do.
   Q: What is this project's "goal"?
   Not "build a program using custom PE32+ executable". WHY exactly do you need "a custom PE32+ executable" (vs., for example, just recompiling your old .c/.cpp program for 64-bit)? What code/binary are you starting out from? What needs to be "different" about your PE32+ image from any "ordinary" 64 bit Windows .exe? Is a 64 bit Windows .exe actually your goal? Or do you need to accomplish "something else"?

2. I assume you have Microsoft Visual Studio.
   Use it to as great an extent as possible: if you can do something in MSVS, then you probably should do it in MSVS. It will make your life much, much easier :)

3. Definitely code up some .c "test modules", and build then build them in MSVS with "/Fa". This will give you a "template" for writing your own assembly code, manually. In particular, it will show you how to pass parameters correctly :)

4. Definitely make use of MSVS tools like dumpbin or 3rd party tools like PE Internals. Compare and contrast "your code" with "other, working examples".

'Hope that helps...

So I can't take credit for this. I'm only posting answer so we can close this question. But the issue was with the portaudio library itself The portinfo.def file was not exporting the method that I was trying to call - the method referenced in the example file.

the fix was to add the following line to the portinfo.def file:

Pa_GetVersionInfo @ 69

Now my client / console app compiles. I will submit a patch later today to portaudio repo for the community to consider. But thanks to @HansPassant and πάντα ῥεῖ