Johannes Rudolph jrudolph

Here's a way to limit the IO usage of a process (or process group).

What did not really make a difference is using ionice to change the priority. In this case, the reason might be, that the background job is a highly concurrent rclone job and it might still dominate the IO queues by the sheer amount of concurrent IO scheduled.

What does work, is using cgroups to limit the total IO bandwidth for a group.

Create a group:

Creating segments from intersecting horizontal and vertical fibers

Sean published results of his volume segmentation models that can detect and distinguish horizontal and vertical fibers (first in Ostober 2024 and later in January 2025)

Idea: recreate the fiber mesh by finding and connecting crosspoint between horizontal and vertical fibers

Process

Separate the fibers by running a connected component analysis over the model output, separately for horizontal and vertical fibers

Volume Cartographer PPM file format

PPM files map U/V coordinates from flattened surfaces back to the original 3D volume coordinates x/y/z and also provide a normal for every point.

The file has a small header and is otherwise a huge array of double values (in the common case, but see header).

Header

Freiburg im Breisgau

The town of Freiburg is located in south-western Germany, in the state of Baden-Württemberg, 150 km (93 mi) south-west of Karlsruhe, 110 km (68 mi) west of Strasbourg, France, and 130 km (81 mi) east of the Alpine passes of the Alps.

Geography

Freiburg lies in the extreme south of Baden-Württemberg and is bordered on the west by France. It lies 500 m (1,600 ft) above sea level, within the southern part of the northern Black Forest at the foothills of the Alps, near the confluence of the rivers Singold and Dreisam, in the historical region of Sundgau, locally referred to as Breisgau. Freiburg is in the traditional wine-growing region of Germany and hosts one of the country's largest wine festivals, the Freiburger Weihnachtsmarkt, which takes place from the last weekend in November until the first weekend in December.

Subdivisions

Yugabyte Debugging Case Study

Problem

Under load, the yugabyte clusters showed a latency spike ~ every 30 seconds. Latencies went up to 4 seconds.

Analysis

Aside from the main problem, we found that one of the servers in the cluster showed CPU saturation during those spikes. Since the spikes were frequent enough, top could be used to identify the yb-master process as the

As of version 2.12.1.0

https://docs.yugabyte.com/preview/architecture/ has some information but too little about the actual implementation details.

The whole project is written in C++.

Components

master(s): provide metadata services and are involved in all kinds of metadata changes, manage the set of tservers, disitrbute tablets to tservers. There's a cluster of masters and RAFT is used to determine a leader. It seems that,

Here's a quick report that I used this branch to compile a binary for Raspberry Pi 1 using https://github.com/scala-native/scala-native/commit/18114562b28e9301c944f7e142ac92d7edd1058c from scala-native/scala-native#1571.

In a quest to update my daughter's music box based on a Raspberry Pi 1, I tried to use scala-native instead of a regular OpenJDK for running the custom software.

Ultimately, I got something working but it was quite a rocky road (and I'm not sure if I would recommend it instead of using Zulu OpenJDK). As mentioned before somewhere in the PR I had to change NativeConfig to default to a 32-bit architecture.

I'm using this config on the project:

nativeCompileOptions ++= Seq("-target", "arm-linux-gnueabihf", "-fno-builtin", "-fno-exceptions", "-march=armv6", "-v")

-# adapted from https://github.com/not-an-aardvark/git-delete-squashed
-git checkout -q origin/main && git for-each-ref refs/heads/ "--format=%(refname:short)" | \
-   while read branch; do mergeBase=$(git merge-base origin/main $branch) && \
-     [[ $(git cherry origin/main $(git commit-tree $(git rev-parse "$branch^{tree}") -p $mergeBase -m _)) == "-"* ]] && \
-     git branch -D $branch; \
-   done

	Model from https://huggingface.co/TheBloke/NewHope-GGML

	llama2JVM ### Instruction:
	llama2JVM Generate scala code that find the the top-p (for nucleus sampling) elements, i.e. the smallest set of elements that reaches a given level `p` of cumulative probability, of an unsorted array of probabilities summing to 1. Expect a power-law distribution, i.e. the number of elements found will be low (< 10). Do not use any data structures besides arrays (in particular, expect that inserting into apriority queue will be too slow). Avoid sorting.
	llama2JVM
	llama2JVM ### Response:
	llama2JVM Here's a possible implementation in Scala that uses binary search and a priority queue to solve this problem.
	llama2JVM
	llama2JVM ```scala
	llama2JVM import scala.annotation.tailrec

	import akka.actor.ActorSystem
	import akka.stream.{ Attributes, FlowShape, Inlet, Outlet, OverflowStrategy }
	import akka.stream.scaladsl.{ Compression, FileIO, JsonFraming }
	import akka.stream.stage.{ GraphStage, GraphStageLogic, InHandler, OutHandler }
	import akka.util.ByteString

	import java.io.{ File, FileOutputStream }
	import spray.json._

	import scala.concurrent.Future