eflag | Package eflag provides a drop in replacement for the flag | Access Management library

Apache Arrow utilizes a pretty similar idea of Java off-heap storage as Apache Ignite does. For Apache Arrow it means that objects like IntVector don't actually store data in their on-heap layout. They just store a reference to a buffer containing an off-heap address of a physical representation. Technically it's a long offset pointing to a chunk of memory within JVM address space.

When you restart your JVM, address space changes. But in your Apache Ignite native persistence there's a record holding an old pointer. It leads to a SIGSEGV because it's not in the JVM address anymore (in fact it doesn't even exist after a restart).

You could use Apache Arrow serialization machinery to store data permanently in Apache Ignite or even somewhere else. But in fact after that you're going to lose Apache Arrow preciousness as a fast in-memory columnar store. It was initially designed to share off-heap data across multiple data-processing solutions.

Therefore I believe that technically it could be possible to leverage Apache Ignite binary storage format. In that case a custom BinarySerializer should be implemented. After that it would be possible to use it with the Apache Arrow vector classes.

This is because of the optstring in getopt:

At 0x5514704B you set EFLAGS. When it has TF flag set, a debug exception (#DB) will be generated by the CPU after next executed instruction. Next after popfd is mov[ebx], eax, thus the exception is generated after it's execution. Since #DB is a trap, eip points to address after the executed instruction, pop eax in your case.

Check if push[ebx] at 0x55147048 has TF bit set.

I've fixed the issue by converting used Sound.wav to mono (1 channel) sound.

There's 2 questions here:

a) How to execute INVD (unsafely)

For this, you need to be running at CPL=0, and you have to make sure the CPU isn't using any "processor reserved memory protections" which are part of Intel's Software Guard Extensions (an extension to allow programs to have a shielded/private/encrypted space that the OS can't tamper with, often used for digital rights management schemes but possibly usable for enhancing security/confidentiality of other things).

Note that SGX is supported in recent versions of Linux, but I'm not sure when support was introduced or how old your kernel is, or if it's enabled/disabled.

If either of these isn't true (e.g. you're at CPL=3 or there are "processor reserved memory protections) you will get a general protection fault exception.

b) How to execute INVD Safely

For this, you have to make sure that the caches (which includes "external caches" - e.g. possibly including things like eDRAM and caches built into non-volatile RAM) don't contain any modified data that will cause problems if lost. This includes data from:

• IRQs. These can be disabled.

• NMI and machine check exceptions. For a running OS it's mostly impossible to stop/disable these and if you can disable them then it's like crossing your fingers while ignoring critical hardware failures (an extremely bad idea).

• the firmware's System Management Mode. This is a special CPU mode the firmware uses for various things (e.g. ECC scrubbing, some power management, emulation of legacy devices) that't beyond the control of the OS/kernel. It can't be disabled.

• writes done by the CPU itself. This includes updating the accessed/dirty flags in page tables (which can not be disabled), plus any performance monitoring or debugging features that store data in memory (which can be "not enabled").

With these restrictions (and not forgetting the performance problems) there are only 2 cases where INVD might be sane - early firmware code that needs to determine RAM chip sizes and configure memory controllers (where it's very likely to be useful/sane), and the instant before the computer is turned off (where it's likely to be pointless).

Guesswork

I'm guessing (based on my inability to think of any other plausible reason) that you want to construct temporary shielded/private area of memory (to enhance security - e.g. so that the data you put in that area won't/can't leak into RAM). In this case (ironically) it's possible that the tool designed specifically for this job (SGX) is preventing you from doing it badly.

@Ross Ridge figured it out (thanks to him!). The details below are what I learned from the OSDev wiki

The Streaming SIMD Extension (SSE) expands the set of instructions recognized by the CPU with some 70 additional instructions and adds some more registers. SSE needs to be enabled before its instructions and registers can be used. The compiler generates machine code which can include SSE instructions and therefore, SSE needs to be enabled.

In the code above, the passing of struct to the function was compiled into machine code which involved the xmm0 register, which is part of the SSE.

The assembly code to enable SSE is given below (adapted from the OSDev wiki). I added it to my bootloader, right after entering the 32-bit protected mode and before entering the kernel. That fixed the problem!

I finally found the solution. Because I am using an old AMV processor, I needed to use an ARM based image for the emulator and not a x86 image. I was then able to run it. Unfortunately my processor was not powerful enough and was lagging as hell when launching the android emulator. Had to buy a new computer.

Combining all the suggestions in the top comments:

We have discovered that the issue occurred because of we were using c# built-in ManualResetEvent from an async code. Seems like it caused some sort of a deadlock for the application threads.

Using SemaphoreSlim instead fixed the issue.