I have been experimenting with SoftReference for my execution recording stuff, so when the heap is not large enough and memory is running low it can discard some recorded values and avoid an OOME. The problem I'm seeing is that SoftReferences do get discarded, the first full GC discards a lot of them but each GC pass releases less and less of them. So it gets in a situation where the GC runs very frequently while a memory sample shows there are a lot of SoftReferences that can be released as you can see in the picture. This avoids the crashing but makes everything super slow.

I played with -XX:SoftRefLRUPolicyMSPerMB and different VMs like Graal and Openjdk but I see similar behaviors :man-shrugging:

I'm not an expert on SoftReferences, but I don't think the graph shows that there a lot of SoftReferences that can be released, only that there are a lot of SoftReferences. It's possible that not all the references are softly reachable.

> An object is softly reachable if it is not strongly reachable but can be reached by traversing a soft reference. You probably already checked this, but have you double checked that the referenced objects aren't strongly reachable from other parts of the code?

yeah, I checked but I can be missing something. Recordings consist of a bunch of ExprTrace objects in a ArrayList, each of them pointing to references, and I changed the strong references by SoftReferences, but it is true that they are values that the application being recorded is using, so some of them will be strong

Also, if you're building some sort of cache, I highly recommend https://github.com/ben-manes/caffeine/

no, it is not a cache, it is the timeline recording of http://www.flow-storm.org

I'll have to keep playing with it

One way to check is to do an .hprof heap dump:

(defn heap-dump
  "Dumps the heap to the outputFile file in the same format as the hprof heap dump.

  `output-path` - the system-dependent filename
  `live?` - if true dump only live objects i.e. objects that are reachable from others"
  [output-path live?]
  (let [b ^HotSpotDiagnosticMXBean
        (ManagementFactory/newPlatformMXBeanProxy
         (ManagementFactory/getPlatformMBeanServer)
         "com.sun.management:type=HotSpotDiagnostic"
         HotSpotDiagnosticMXBean)]
    (.dumpHeap b output-path live?)))

yeah, that is the same as clicking heap dump on visualVM

will have to create examples with smaller heap, since 15Gb heap is going to be slow to dump and analyze I think

there is definitely something funky going on in my code

I simulated a similar situation with this

(ns user
  (:import [java.lang.ref SoftReference]
           [java.util ArrayList]))

(def coll (ArrayList.))

(defn make-entity [size]
  (long-array size))

(def max-entities (* 1024 1024 30) ) ;; 30Gb of entities

(defn run []
  (loop [i 0]
    (when (< i max-entities)
      (let [e (make-entity 1024)] ;; 1 Kb entity
        (.add ^ArrayList coll (SoftReference. e))

        (when (zero? (mod i 100000)) (println "Created " i "entities")))
      (recur (inc i)))))

and I get a much more healthy pattern

and I'm starting to think there is probably nothing wrong with my code, but with the nature of what I'm trying to do and the kind of execution I'm recording. So maybe SoftReferences aren't going to make this situation better after all

I figured out the problem here, wasn't on my code, and wasn't bad jvm behavior, the whole thing was kind of dumb. The original problem is that I was accumulating millions of entities of ~ 56 bytes each, and I wrapped them in SoftReferences which are 40 bytes each, so even when the original entities got discarded under mem pressure I was replacing them with something that has almost the same size . Lesson learned use SoftReferences with big enough things, like in the simulation above.

Lesson two, if I'm going to simulate something, simulate the right thing

In case it's of any use, I've been running this patch in Clojure itself for a few years https://gist.github.com/vemv/23720829a6e56c9a8e9cfb9173defa21 it certainly made the GC characteristics much better (of course, this is an unrelated use case - often the tools that are great of X aren't for Y)

For interactive Clojure code snippets I'd recommend clojure-mode (a CodeMirror mode). Two demo pages that use that: https://babashka.org/sci.configs/ https://squint-cljs.github.io/squint/

Right. But that's a bit... manual. An ideal experience would be something like Clerk but that spits out an HTML file, maybe with a bunch of other static resources.

Maybe ask in #C035GRLJEP8 - there are some people who compiled clerk with their own CLJS libs so you can use them from SCI which makes it interactive client side

Ah, will do, thanks.

Clerk can spit out a HTML file :)

I also made a tiny lib once that used SCI + codemirror/clojure-mode + markdown: https://github.com/borkdude/cljs-showcase This is how it looks. Not that pretty, I kept it minimal: https://borkdude.github.io/cljs-showcase/

I think you can do something similar with clerk, to show an inline editor where you can eval some stuff

Thanks! Mulling it over... Maybe I'll end up not needing allowing evaluation at all.

Just want to say what you described sounds like something I have wanted several times. Some kind of lightweight ClojureScript notebook that runs entirely client side. Not sure if that's exactly what you meant.

Yeah, pretty much.

@U9EQP1K0X don’t you have a clerk notebook that does that laying around?

Isnt Clay/Kindly doing this? (Not sure about the eval part)

if you end up building something with squint, it's diy, but for a side project I was playing around with a different workflow and used https://github.com/borkdude/bun-squint-loader and https://github.com/BjornTheProgrammer/bun-plugin-html to put together a bun "build" that compiles/minifies/inlines any CLJS referenced by the html entrypoint.

The actual project is a broken WIP, but you can see an example of the build process here: https://github.com/casselc/clj-passkey-demo. The public folder compiles to a single inlined-everything static HTML file that's around 12KB gzipped.

@U2FRKM4TW, @U5H74UNSF you mean the experiment with clojure-nested-in-markdown experiment with clerk viewers? https://snapshots.nextjournal.com/clojure-mode/build/5d88847aecd253e047f36565e0455bfec7f4964d/livedoc/index.html (ux is not optimal and we have to improve its performance by probably squintify its sources, please scroll to the Usage section)

styles are broken, sorry...

If you want entirely client-side, you could consider maria.cloud as well 🙂

Ah! That's pretty much it. I knew I've seen it somewhere. Thanks!

We’re close to releasing v2 of Maria, btw. 🤞:skin-tone-2:

So you want to have a language-agnostic behavior that's based on language-specific constructs. That's like wanting to eat peanut butter while having a severe allergy to peanuts. :) If you don't want to write rules for every language out there, you can add a user-level ability to customize such rules. In this case, it seems that you only need a rule to determine valid tokens.

you're basically describing vim's 'iskeyword' setting, which deals with this on a per file-type basis: https://neovim.io/doc/user/options.html#'iskeyword'

I mean, I'm trying to integrate with LSP, which supposedly needs to be language-agnostic 🤷

what are you trying to integrate? lsp usually sends ranges, right?

No, LSP can send ranges, but it's not mandatory (and AFAIK only one server that I integrated so far sends ranges)

I... might have solved with a horrible idea. Basically, I got all suggestions and mapped all non-word chars; then I generated a regex with that info, searched for the current word under the cursor with that regex, and called that "the prefix"

omg do you do that on every keystroke?

that's very clever tho