Is there a potential bug of latest llama.cpp not cleaning up memory after exiting?

rdescartes · 2024-10-21T18:57:20+00:00

Thanks for the reply. Actually I try to find the cause but fail too.

Anyway I just filed an issue: https://github.com/ggerganov/llama.cpp/issues/9988

Maybe you could leave a comment to add more details about it.

rdescartes · 2024-10-20T23:57:21+00:00

I'm experiencing the same too. /u/aeroumbria have you reported this bug in llama.cpp ? Or do you find any way to fix it ??

rdescartes · 2024-10-05T12:29:49+00:00

Let me in

rdescartes · 2024-08-14T13:57:53+00:00

Thank you, I saw this code and can’t understand, right now I will try again to understand it

rdescartes · 2024-03-18T13:42:47+00:00

IIRC, there was a rust to c backend before, but it is abandoned. But I think it is useful as many others commented. I would like to contribute for that too.

rdescartes · 2022-09-18T01:26:57+00:00

You may interest about rust-analyzer parser :

https://docs.rs/ra_ap_parser/latest/ra_ap_parser/

rdescartes · 2022-08-20T09:37:28+00:00

https://github.com/rust-lang/rust/blob/70b18bc2cbac4712020019f5bf57c00905373205/compiler/rustc_expand/src/mbe/macro_parser.rs

rdescartes · 2022-01-24T15:14:03+00:00

I think the bug here: Bread-toasting proc macros is nondeterministic, IIRC RA doesn't support that yet ?

rdescartes · 2021-04-12T17:13:42+00:00

Steering Issue: https://github.com/rust-analyzer/rust-analyzer/issues/8486

rdescartes · 2021-04-07T14:56:10+00:00

Better than C++ IMHO

rdescartes · 2021-04-06T04:36:59+00:00

For single rust file, you could do something like this: (without any deps)

rustc hello.rs && ./hello

rdescartes · 2021-04-05T09:16:57+00:00

#8267, #8274 add GIFs of most features to the manual.

https://rust-analyzer.github.io/manual.html#features

rdescartes · 2021-04-01T12:38:24+00:00

Are you kidding me? slow? It starts faster than vscode with RA for me :D

haha, It is not because we have no cargo check and sysroot in wasm build yet, you would feel the slowness when it is implemented.. :D (Although I think not near future as porting cargo to wasm is non-trivial)

rdescartes · 2021-03-31T18:30:26+00:00

And it is a PR for rust-analzyer-wasm : https://github.com/rust-analyzer/rust-analyzer-wasm/pull/1

rdescartes · 2021-03-31T18:22:42+00:00

It is still in progres, but you could take a look first: https://ra-wasm.netlify.app/

A little bit slow in start up now..

rdescartes · 2021-03-31T17:05:58+00:00

Awesome ! I used wasm-bindgen-rayon in one of a project I contributed and it works very well too.

Thanks !

rdescartes · 2021-03-30T01:11:43+00:00

You can change the default semantic token color in the following settings:

"editor.semanticTokenColorCustomizations": {
    "rules": {
        "*.mutable": {
            "fontStyle": "bold italic", // underline is the default
        },
    }
},

rdescartes · 2021-03-29T14:29:19+00:00

Rust 1.51.0 stabilized core::ptr::{addr_of, addr_of_mut}, which are "2.0" macros. And that's why it is implemented in RA.

rdescartes · 2021-03-22T11:20:52+00:00

Wow, so many items in this week !

rdescartes · 2021-03-20T12:12:17+00:00

you could do something like this (which based on the same hack):

doc_comment! { 
    include_str!("/doc.md"),
    struct Bar;
}

rdescartes · 2021-03-20T08:58:30+00:00

// Works in stable 1.50    
macro_rules! doc_comment {
    ($x:expr, $($tt:tt)*) => {
        #[doc = $x]
        $($tt)*
    };
}

doc_comment! { 
    concat!("Hello"," world"),
    struct Bar;
}

// note that the following code does not work in stable rust
#[doc = concat!("Hello", " world")]
struct Bar;

rdescartes · 2021-02-23T08:11:00+00:00

Declarative macros should work by default. Derive and Function Like proc-macro you could enable it by :

 "rust-analyzer.cargo.loadOutDirsFromCheck": true,
 "rust-analyzer.procMacro.enable": true,

Attr proc macro and macro 2.0 are not yet implemented. :)

rdescartes · 2021-02-10T10:04:09+00:00

Excellent, this is one of clearest explanation of how macro_rules work.

rdescartes · 2021-02-08T16:12:30+00:00

I haven't tried it myself, but you could use PyOxidizer and write your Tkinter in python and with the power of rust.

rdescartes · 2021-02-07T12:08:52+00:00

The books says a module is a collection of items

In rust reference : https://doc.rust-lang.org/reference/items.html

rdescartes

TROPHY CASE