Ian Rogers

@mmirwaldt An example use of the metrics is branch miss rate. The categorization is used in some places to color code the metric value. I think we're talking about something different.

I'm trying to come up with enum constants that classify a performance metric's value. My constants are unknown, good, less_good, nearly_bad, bad. Can't help but think there are better terms, like mediocre. An AI implementation looks to be heavily derived from a trip to HR:

Another curious location: by gum:

Hmm. "Peel park" looks to have the Refuge Assurance building in the background. The garden layout doesn't appear to match that of the current Vernon park:

By way of @martin_0401 I found out Hobson's Choice was filmed around Stockport. YouTube have it available for free with ads: youtu.be/o7RgwJ9htag?si… If I had an apple+ account A Taste of Honey is apparently available.

Last night, what JD Vance didn’t say said everything.

So were the old tunnels on the power station bank? Did they go under the Goyt? Were there bits of the power station on the New Zealand road side of things? Or perhaps at Vernon mill.

But the power station was on the other bank and further downstream:

Whilst I'm thinking of @martin_0401 , the Stringer's tunnel are on New Zealand road bank of the Goyt. From Martin's video:

@debasishg @gautshen @KernelRecipes There is also code in the kernel to periodically break long loops, for rescheduling and the like e.g.: #L83" target="_blank" rel="nofollow noopener">github.com/torvalds/linux… This is the manual placement of something akin to garbage collection safe points.

@iiirogers @gautshen @KernelRecipes Good point .. I think GC may have some advantages when u have resources that take a long time to be released. When the limit is about to be reached, GC can kick in and release some of them. Not sure how hazard pointers will handle this.

Hazard pointer is an interesting data structure that implements a memory management methodology that allows memory reclamation for arbitrary reuse. This talk from @KernelRecipes 2024 presents a new synchronization API that combines the 2 data structures hazard pointers and reference counters to leverage the benefits of each mechanism. It uses hazard pointers as fast-paths, and falls back to reference counters either explicitly when the reader expects to hold the object for a long time, or when no hazard pointer slots are available. Hazard pointers, being used on the fast paths improve upon the speed and scalability. Link to the talk - Hazard pointers with reference counter - youtu.be/mnQlQXZn5EI?si… Original paper on Hazard pointers - Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects by Maged M. Michael - cs.otago.ac.nz/cosc440/readin…

@abhi9u The young generation sounds very small from this, most likely the returned object and things it references. Fwiw, I have this immutable hypothesis, to go along with the generational hypothesis, that old things don't change.

@iiirogers Good questions, never thought about this. After a scan, the surviving objects move to old gen which reduces the young gen size to make sure it doesn't run again very soon. On next run only the new objects get scanned GC runs on fn returns only if size(young) > threshold

CPython had introduced an optimization in their GC in the 3.13 release which is being rolled back now due to a performance regression. Normally, the GC scans the young generation every GC cycle, while the older generations are scanned at a lesser frequency, but every few cycles the GC ends up scanning the whole heap which results in long pause times that can impact the tail latency of applications. They tweaked the GC algorithm so that every cycle it scans the young gen and a fraction of the oldest part of the old gen. This would mean that the pause times are more even, and overall the memory is still being reclaimed. This showed improvements in the benchmarks but after the 3.13 release a few regressions were found. E.g. building documents using sphinx showed a ~50% slowdown and most of it was inside the GC. Links to GitHub discussion on replies.

@abhi9u Would the runtime structures be in the permanent generation? Could the amount of cycles being looked for be reduced by capturing what parts of the heap changed since the last scan? It sounds very heavy weight to be running this on function returns without winning back heap.

@iiirogers Within the runtime there are few cycles which are always present. E.g. module functions refer the module's dict and the dict refers the functions. Exception's traceback contains frames which contains exceptions. However, I think majority of objects don't have cycles.

@abhi9u How often do the references form cycles? Is there much heap being reclaimed?

If you want to learn how the GC works: blog.codingconfessions.com/p/cpython-garb…

@mechanicker @eatonphil Agreed. With glibc opendir can allocate 32kb to 1mb, llvm libc uses 1kb. I worry about bugs from non-atomic directory reads with the smaller size.

There's no way to read a directory without allocating for all entries in the directory in Go? No way to get an iterator instead?

@shipilev People with bugs in their GC blame the RAM 😉

At some point, I would argue for including a simple memtest routine that runs at the end of the JVM crash reporting sequence, read-writes the whole heap with various bitmasks, and often says in ALL CAPS: TEST YOUR MEMORY. shipilev.net/jvm/test-your-…

@jfbastien I find it confusing that Java/Kotlin aren't memory safe in the Android case 🤷 It was found in early Android releases that there were fewer bugs wrt iOS due to this. Mozilla's original response to, "stop losing our fingers and thumbs to C++," was JavaScript.

Given Android team’s findings that buggy code has half life where bug rate lowers on older code, we could write less code… or could revive Symbian/BlackBerry/Windows Phone to have well-baked code! Vintage retro compute? Nah, I’m into low-background Cesium-137-free source code!