General-Purpose | general purpose programming language | Data Visualization library

Here is my own answer for whom might need the same clarification;

As my question based on the confusion of the roles of the SCU and GPIO, I placed the definitions with correct figures in order to make a LED ON and OFF including initialization of the pin. Please use the code in my original post above for the device requirements and complete the LED pin part by the code below;

1. The w is a template modifier. It causes the inline asm to contain the 32-bit name of the register (w0, etc) instead of its 64-bit name (x0) which would be the default. See the documentation linked by David Wohlferd. You can also try it and note that if you write %0 instead of %w0, the generated instruction uses the 64-bit x register. That is not what you would want since these should be 32-bit loads and stores.

2. Both. As usual for GCC-style extended asm, %w0 refers to operand number 0 of the inline asm (with, as mentioned, the w modifier to use its 32-bit name). Here that is the one declared with "=&r" (result). Since the constraint is r, this operand will be allocated a general-purpose register, and all mentions of %0 (respectively %w0) in the asm code will be replaced with the name of that register. In the Godbolt example above, the compiler chose x9 (respectively w9).

   The (result) means that after the asm statement, the compiler should take whatever is left in w9 and store it in the variable result. It could do this with a store to memory, or a mov to whatever register is being used for result, or it could just allocate result in that variable itself. With luck, the optimizer should choose the latter; and since result isn't used for anything after the asm, it should not do anything further with that register. So in effect, an output operand with a variable that isn't used afterwards is a way of telling the compiler "please pick a register that I can use as scratch".

3. This is two constraints, I and r. Constraints are documented by GCC: simple and machine-specific, and when multiple constraints are given, the compiler can choose to satisfy any one of them.

   I asks for an immediate value suitable for use in an AArch64 add instruction, i.e. a 12-bit zero-extended number optionally shifted by 12 bits which is a compile-time constant. r, as you know, asks for a general-purpose register. So if you write any of atomic_add(1, &c) or atomic_add(1+1+1, &c) or atomic_add(4095, &c) or atomic_add(4096, &c), the second line of the asm statement will be emitted as immediate add instruction, with your constant encoded directly into the instruction: add w9, w9, #1 and so on. But if you write atomic_add(4097, &c) or atomic_add(my_variable, &c), the compiler will generate additional code before the asm to load the appropriate value into some register (say w13) and emit add w9, w9, w13 inside your asm. This lets the compiler generate the more efficient immediate add whenever possible, while still getting correct code in general.

fastai has pre-trained models for imagenet that you can re-use & transfer learn against. You can probably use a pre-trained resnet network, then retrain it on a dataset you come up with.

Here's one example from the net, but you can search "fastai transfer learning" for more examples: https://towardsdatascience.com/transfer-learning-using-the-fastai-library-d686b238213e

The hardest part will be you getting a dataset. Here is an example, but I'd honestly recommend working through lesson 1 and 2 of the free fastai course. It'll give you a better overview.

TL;DR - if you can search google for "residential floor plan" or something, you can create a dataset. The hard part will be choosing what non-floor plans to include in your data set. Probably you'll need a lot of random things, but also many things that look close to a residential floor plan, but aren't, so it can get good at distinguishing between a floor plan and a maze, and a pinball layout, and a spreadsheet, etc.

You can use a recursive function (changed some parts of the code, check comments):

This answer is a cross-post from Kotlin Discussions. Credit goes to Lamba92_v2 of the JetBrains Team, who linked his solution in his project kotlingram.

I noticed I had another issue related to publishing: Signatures and POM information where not applied to all modules. But given Lamba92_v2's code I could resolve all publishing-related issues:

If you're asynchronously running this between any two arbitrary instructions in an existing program, you need to make sure you save/restore ALL the architectural state that isn't call-preserved, like an interrupt handler would.

You missed r10, rflags, and XMM0..5¹. https://docs.microsoft.com/en-us/cpp/build/x64-calling-convention?view=msvc-160

For safety, you also need to make sure you reserve the full 32 bytes of shadow space, so the DLL functions don't step on any of your saved register values. You say your testing shows that wasn't a problem now, but some future Windows version might have DLL functions that do take advantage of that shadow space.

Footnote 1: Also x87 st0..7 or MM0..7. And AVX YMM0..15, although Windows API functions are unlikely to be affecting their high halves by running vzeroupper or anything. Or touching AVX-512 ZMM0..31 or k0..7. So you can probably get away without doing an xsave / xrstor, instead just saving XMM0..5.

Why not use Pandas?

IL2CPP is tightly connected to the Unity environment and it's not possible to use it outside of Unity. You would need to write your own converter(?) to do such a thing.

IL2CPP doesn't do any magic in terms of performance improvement. Comparing C++ with C# with IL2CPP code should give (almost - more below) no performance benefit.

IL2CPP is performant compared to C# code written for Unity specifically for few reasons that have nothing to do with C++.

Why Unity is unique and needs IL2CPP:

• Unity API is very heavily reliant on main thread performance, as the whole Unity API was written almost 10 years ago, where 2 Core CPUs were top-notch and everyone believed that we will have 20-50GHz single-core CPUs by now.
• Unity makes a lot of assumptions that you will use their API for everything, begging from IO to Threading and GPU access, which is heavily bound to C++ core.
• Unity needs to be wrapped with Unity objects (MonoBehaviours and GameObjects) to be used for almost anything, you cannot write your own native anything. (This is a simplification)
• Unity is written in C++, so it needs to do something very similar to Marshalling, and it's not very efficient.

So why IL2CPP?

• Unity cannot convert its already very legacy backend (Mono) and its legacy API to be multithreaded since Mono have a lot of assumptions about your code that are not easily convertible to "simple" unity API.
• Unity core is written in C++, so they are eliminating any form of Marshalling all together by skipping Mono "translator".
• IL2CPP converts highly inefficient C#, single-threaded code to multithreaded C++, where possible, and it does this by analyzing IL code.

Is it worth converting other C# to C++?

No! Compare any arbitrary, optimized C# code that was precompiled by AOT to (modern) C++. You should get the same performance! Identical I would say.

C# is compiled to IL (Intermediate Language) which as the name suggests is Intermediate. It's converted in runtime to Native Binary code (only when needed), that is what C++ is compiled into. You can force this conversion by skipping IL generation by running Ahead of Time compilation (AOT).

The ONLY thing that your C# code will be less performant is when you are abusing GC's ability to clean up after you.

Hardware saves the user-space program-counter on the kernel stack, as part of how exceptions / interrupts work on x86. (Or for the syscall entry point, user-space RIP is in RCX and does have to get stored manually into the PCB).

The rest of user-space context is saved on the kernel stack for that task by software after entering the kernel. Context-switch swaps kernel context including kernel stack pointer to be pointing at the new task's stack, so returning, eventually to user-space, will restore the new task's user-space state.