C-programming | C programming Portfolio | Portfolio library

Answered by José Pereda in comments

"Did you add the required dependencies (like org.graalvm.nativeimage:library-support) to the project?"

Adding the dependency solved my problem. Thanks

Memoize returns function, so you have to use def:

• The claims of there being "32" keywords in C refer to the original ANSI-specified version of C from 1989, aka C89.
  • Because this is the Internet, and because the real C specifications are behind ISO's ridiculous paywall most people so-inclined probably can't fact-check the claim.
  • And it's not a claim worth fact-checking: the number of keywords in a language is utter trivia of no consequence.
• The ISO/IEC 9899 specification you linked to refers to C17 (the proposed updated C specification in 2017) which postdates C89 by 28 years.
• It should come as no surprise that a future updated revision of a programming language introduces new keywords.

Historically, when C was introduced, people were impressed by its minimalist syntax and how the language's design effectively reified everything by implementing functionality as library features instead of language features which is what keeps C simple and helps mitigate every language's designer's fears about feature creep.

In comparison, C's early contemporaries like COBOL, opted to implement functionality into their own languages as first-class features, which is why COBOL has over 300 keywords; so I'll admit that using the stark difference in keyword-count does serve as a proxy for language-complexity and by extension: a way to almost quantify good design. But using it as the basis for comparing languages today in 2021 is of limited-utility as the most relevant programming languages today¹ are already either inspired by C or derived from it somehow, and they all share C's decision to do things in the library instead of the language, so all those languages similarly have a low keyword count compared to COBOL, SQL, and others, and so that's why C's keyword count just isn't interesting anymore.

1: C-inspired or C-derived languages in use today: C++, Objective-C, Java, Groovy, Swift, C#, JavaScript, TypeScript, Go, PHP, Perl. Other popular languages that aren't modelled on C (like Haskell, OCaml, etc) do share C's library-first philosophy, but I can't say if C originated it or not - but I feel that languages opting for library-first designs is inevitable: the cost to implement language-features is easily ten-fold that of implementing library features.

Question shows that when Core is as created by cudaMallocManaged, bug appears. However, for Core created by cudaMalloc and cudaMemcpy, the kernel gives the correct answer.

This bug relates to CUDA DOC.

In detail, the CUDA DOC denotes that:

The CUDA compiler follows the IA64 ABI for class layout, while the Microsoft host compiler does not. Let T denote a pointer to member type, or a class type that satisfies any of the following conditions:

T has virtual functions.

T has a virtual base class.

T has multiple inheritance with more than one direct or indirect empty base class.

All direct and indirect base classes B of T are empty and the type of the first field F of T uses B in its definition, such that B is laid out at offset 0 in the definition of F.

Let C denote T or a class type that has T as a field type or as a base class type. The CUDA compiler may compute the class layout and size differently than the Microsoft host compiler for the type C. As long as the type C is used exclusively in host or device code, the program should work correctly.

Passing an object of type C between host and device code has undefined behavior e.g., as an argument to a global function or through cudaMemcpy*() calls.

Since both of Box and Core are children of Managed (empty class overloading new and delete operator).

If we place the box (non-pointer object) at the first field of Core, we meets the fourth case All direct and indirect base classes B of T are empty and the type of the first field F of T uses B in its definition.

Due to the different ABI between Windows host (x64) and CUDA device (IA64), the undefined behaviour of kernel appears as result.

-------------> Personal analysis

The CUDA DOC also denotes that the undefined behaviour of kernel can be associated with class which is created on host but run on device and vice versa.

In other words, Core created using cudaMalloc may avoid the bug by a consistent creation and run environment (both host or both device).

The same thing for the box as pointer object, because it eliminates the bug by avoiding the fourth case (children class of a empty base class locates at the first field).

I think you want:

The problem is that when you give appendo a fresh variable on the left and a fresh variable for the result, it can produce arbitrarily many answers, none of which will lead to a solution for your overall reverso question. Witness the definition of appendo:

To answer your question:

Due to memory padding and allocation granularity, each block probably requires more memory than the calculated size. You should always check the return value of new. If it is nullptr, the allocation failed.

However, if the total number of nodes for all networks is known up front, it would be more efficient to just cudaMalloc the memory for all nodes, (and all networks). Then, in the kernel just update the pointers accordingly.

Something like this:

Is there some way to refactor only the controller, i.e. "topmost" methods into being asyncronous so server won't run out of threads?

No.

You can think of it this way: synchronous calls block a thread. As long as your business logic / DAL methods are synchronous, they will block a thread.

As some have noted in the comments, Task.Run will allow those methods to block a thread pool thread instead of the calling thread, and that's a fine approach for many GUI apps (block thread pool threads instead of the GUI thread), but it's counterproductive on server apps (block one thread pool thread instead of another thread pool thread).

I recommend first analyzing your app and determining which requests are the slowest or most frequently called, and changing just those to be async all the way. You can use the flag argument hack (attribution: me) to avoid code duplication in your logic/DAL types when creating asynchronous equivalents of synchronous methods.

atomicAdd() has been supported for a long time - by earlier versions of CUDA and with older micro-architectures. However, atomicAdd_system() and atomicAdd_block were introduced, IIANM, with the Pascal micro-architecture, in 2016. The minimum Compute Capability in which they are supported is 6.0. If you're targeting CC 5.2 or earlier - or if your CUDA version is several years old - then they might not be available to you.

This is actually likely to be the case, since even for the current version of CUDA, nvcc will default to Compute Capability 5.2 if no other value is specified with -gencode or -arch (e.g. if you run nvcc -o out my_file.cu).