Puppy-щеки

To accomplish this, we needed to find a place to “stuff” the string in the DWARF DIE tree. Using a
DW_TAG_subprogram was deemed the most straightforward and space-efficient location. This means we create a synthetic DISubprogram which is not a real function in the compiled program; it exists only in the debug info as a container.
<...>
When a trap is hit in the debugger, the debugger retrieves this string from the debug info and shows it as the reason for trapping.

GPU code can now use Rust's standard library. We share the implementation approach and what this unlocks for GPU programming.

This works because of our custom hostcall framework. A hostcall is analogous to a syscall. A hostcall is a structured request from GPU code to the host CPU to perform something it cannot execute itself. You can think of it like a remote procedure call from the GPU to the host to achieve syscall-like functionality.

To end users, Rust's std APIs appear unchanged and act as one would expect.

xxx: ssh over mattermost =)
yyy: Лучшие практики =)

I’m all for learning C if it will be useful for the job at hand, but you can write lots of great software without knowing C. [выделение моё]

A few people repeated the idea that C teaches you how code “really” executes. But C is an abstract model of a computer, and modern CPUs do all kinds of things that C doesn’t show you or explain. Pipelining, cache misses, branch prediction, speculative execution, multiple cores, even virtual memory are all completely invisible to C programs.

C is an abstraction of how a computer works, and chip makers work hard to implement that abstraction, but they do it on top of much more complicated machinery.

impl<T> Hash for UnconditionallyEqual<T> {
    fn hash<H: Hasher>(&self, _state: &mut H) {}
}

const hello_world_in_c =
    \\#include <stdio.h>
    \\
    \\int main(int argc, char **argv) {
    \\    printf("hello world\n");
    \\    return 0;
    \\}
;

    let hello_world_in_c = "\
    #include <stdio.h>\
    \n\
    \nint main(int argc, char **argv) {\
    \n    printf(\"hello world\\n\");\
    \n    return 0;\
    \n}";

    let hello_world_in_c = r#"#include <stdio.h>

int main(int argc, char **argv) {
    printf("hello world\n");
    return 0;
}"#;

macro_rules! text {
    (#[doc=$first_line:literal] $(#[doc=$lines:literal])*) => {
        concat!($first_line, $("\n", $lines),*)
    };
}
let hello_world_in_c = text! {
    ///#include <stdio.h>
    ///
    ///int main(int argc, char **argv) {
    ///    printf("hello world\n");
    ///    return 0;
    ///}
};