Please do not cross-post between #beginners and #clojure

What kind of preparation? you need to set up some state or just big complicated inputs?

Generally, jmh is good at setting up a variety of states and inputs

Essentially prepare a Java object that cannot be reused. It has to be created anew before each run but that preparation is not relevant to what needs to be measured.

I have never used JMH but I believe it requires generating a class? In this instance I need something like Criterium where you can measure things dynamically.

it needs to be recreated before each call or before each benchmarking run?

jmh can be used dynamically as well

Before each call

Whereas from what I see Criterium only accepts a function. Unless I am mistaken, it doesn't accept anything around that function.

I'm not sure jmh lets you do that, either

what I'd do in this case is measure function+setup then only setup and substract

silly but works

exactly. perhaps tufte could also be used, it's a profiling tool where you can bucket things

Yup I thought about doing (setup + fn) - setup but it sounds really suboptimal and can potentially be inaccurate when setup takes significantly more time than fn.

I used Tufte in the past and it might serve the purpose since it's more of a "profiler". However I don't know how "good" it is for a task that is closer to "benchmarking" (just one expression). Eg. I expect quite a lot of GC, which Criterium tries to mitigate, I don't think Tufte does that kind of work.

Another option is to create a pool of objects to be used in advance then consume it, but you'll need a lot of them

A huge amount! Funny no one had this issue before.

usually the setup is not one-off. can you describe the case a bit more?

It is about allowing users to benchmark code written in another Lisp. It also runs on the JVM and the "runner" is written in Clojure. Prior to evaluating the benchmark code, a "context" object must be copied (that's the setup) so that each call is run as-if for the first time.

what is the other Lisp? just curious

Convex Lisp from https://convex.world/ It's a distributed, immutable Lisp closely modelled on Clojure. Still pre-alpha so no big fuzz about it (concept is from the creator of core.matrix 😉 ).

https://convex.world/documentation/tutorial

I am sure people have had the issue before, at least in the form of misinterpreting the results of criterium benchmarks :-)

The creation of many objects before the benchmarking runs is the only way I can think of that would not require modifying criterium code

Naively, I guess modifying Criterium to have such a "preparatory" phase might mess with its base design (the work is does with overhead estimation, GC, ...)

If the run times of the thing you want to measure is, for example 1/10 of the time required to set up each one, then your preparation time will be 10x longer than the time measured during Criterium measurements of the code you want to measure.

Criterium is very flexible on how long you can spend doing measurements, but by default it spends about 10 seconds running the code you want to measure, as many times as it can run during that time, just for its 'warm up' period where it tries to ensure your JVM code has been JITed, and then 30 or 60 seconds of repeatedly running it after that. It discards the stats from the warmup time and reports based only on the (usually) longer measurement period that happens after taht.

What does "if used correctly" look like? I wasn't able to get babashka.process to terminate

It depends on your use case

Feel free to make a repro and I can probably say more about it. It's hard to speak in general terms.

A long-running server process that needs to run a command and capture stdout

OK

I'll give inherit a try. I missed that in the docs. Thanks

I also used babashka.process/check instead of a deref

With :inherit you're not able to capture the string though. check also does a deref, but throws when the exit value isn't 0

Ah ok. That won't work then

what you can do is:

(slurp (:out (babashka.process/process ["ls"] {:err :inherit}))

and this will forward stderr to System/err, so you can see if anything goes wrong

Cool. I'll try that. Thanks

E.g.:

user=> (slurp (:out (babashka.process/process ["ls"] {:err :inherit})))
"CHANGELOG.md\nLICENSE\nREADME.md\ndoc\nproject.clj\nresources\nsrc\ntest\n"

So omit check or an explicit deref?

yeah, the slurp will block the process until it finishes

Perfect

This appears to be working now. Thanks for your help @U04V15CAJ

:thumbsup:

The problem is called interval merge in bioinfo at least. Sort values on their start/ends. As long as interval i overlaps with i+1 extend interval i with the end of i+1. If i does not overlap start a new one. Never solved that problem functionally though.

yeah that's what I came up with

I'm having a hard time writing it out functionally though

A reduce where you keep track of the current interval you are extending and the list of intervals up until now?

I have little time today, but will write it out tomorrow

(let [i #{[1 2] [3 5] [4 6]}]
    (->> i
         (sort-by first)
         (reduce (fn [r [a b :as n]]
                   (let [[x y] (last r)]
                     (if (and y (< a y b))
                       (conj (vec (butlast r)) [x b])
                       (conj r n))))
                 [])))

nice thanks 🙂 it's pretty similar to what I came up with:

(defn merge-intervals
  [is]
  (if (empty? is)
    []
    (let [is' (sort-by first is)]
      (reduce (fn [xs [a b]]
                (let [[a' b'] (last xs)]
                  (if (<= (dec a) b')
                    (conj (vec (butlast xs)) [a' (max b b')])
                    (conj xs [a b]))))
              [(first is')]
              (rest is')))))

and yeah, I'd like to find a way to get rid of the (conj (vec (butlast xs)))

...although I suppose it might not matter unless I have lots of intersections (which I don't)

(let [i #{[1 2] [3 5] [4 6]}]
    (->> i
         (sort-by first)
         (reduce (fn [r [a b :as n]]
                   (let [c     (dec (count r))
                         [x y] (get r c)]
                     (if (and y (< a y b))
                       (conj (vec (subvec r 0 c)) [x b])
                       (conj r n))))
                 [])))

yeah okay good idea

you can remove the vec call there as well

Thanks. That's been my backup plan. I didn't see a way to set environment variables with this, so I've been reluctant to reinvent the wheel if there's a ready made solution out there

babashka.process is just a thin layer over processbuilder

it also exposes the underlying process as :proc so you can do anything you want without being blocked by a "wrapper"

I know it might be a hot take, but "no they don't"

how did they feel about using jboss or some other jee type app server? I'm pretty sure I recall the error messages being way worse in Java land.

And in particular, Clojure 1.10 has introduced a lot of improvements in this area. Random 5 minute googling might easily give results from older versions.

Well. They are not great, but getting better Also a few libraries that try to improve the situation

@UK0810AQ2 https://www.youtube.com/watch?v=Yt4zQqndLdQ Every annual Clojure survey trashes the stack traces. Java? Excellent choice of bar to clear! 👏 Sadly, the real bar is set by Common Lisp. @U2FRKM4TW Yes, old Google hits should be vacuumed, agreed. The weird thing? No one asked how I saved the sale. Or congratulated me on doing so. You yobbos never change....

FYI, part of the win was figwheel's error reporting, right down to the line number and code, IIRC. Sweet. Should be the default for Clojure.

Not sure where you are in your Clojure journey but perhaps #beginners might be a more helpful channel for questions like this, since folks there have opted in to doing more than just answering Qs — they’re happy to help teach folks about the reasons and alternatives and idioms…