2024 on Ricky

Rules that terminal programs follow

Wed, 25 Dec 2024 08:45:00 +0800

“Rules” that terminal programs follow
rule 1: noninteractive programs should quit when you press Ctrl-C
rule 2: TUIs should quit when you press q
rule 3: REPLs should quit when you press Ctrl-D on an empty line
rule 4: don’t use more than 16 colours
rule 5: vaguely support readline keybindings
- rule 5.1: Ctrl-W should delete the last word
rule 6: disable colours when writing to a pipe
rule 7: - means stdin/stdout

Smarter than 'Ctrl+F': Linking Directly to Web Page Content

Wed, 25 Dec 2024 08:45:00 +0800

Smarter than ‘Ctrl+F’: Linking Directly to Web Page Content

syntax

https://example.com/page.html#:~:text=[prefix-,]textStart[,textEnd][,-suffix]

example

https://developer.mozilla.org/en-US/docs/Web/URI/Fragment/Text_fragments#:~:text=without%20relying%20on%20the%20presence%20of%20IDs

LocalStorage vs. IndexedDB vs. Cookies vs. OPFS vs. WASM-SQLite

Fri, 29 Nov 2024 14:58:29 +0800

LocalStorage vs. IndexedDB vs. Cookies vs. OPFS vs. WASM-SQLite

The available Storage APIs in a modern Browser

Cookies

Cookies store small pieces of key-value data that are mainly used for session management, personalization, and tracking. Cookies can have several security settings like a time-to-live or the domain attribute to share the cookies between several subdomains.

LocalStorage

LocalStorage is only suitable for storing small amounts of data that need to persist across sessions and it is limited by a 5MB storage cap. Storing complex data is only possible by transforming it into a string for example with JSON.stringify(). The API is not asynchronous which means if fully blocks your JavaScript process while doing stuff. Therefore running heavy operations on it might block your UI from rendering.

How I configure my Git identities

Mon, 25 Nov 2024 17:35:35 +0800

How I configure my Git identities

includeIf

[includeIf "gitdir:~/code/**"]
path = ~/.config/git/personal
[includeIf "gitdir:~/work/**"]
path = ~/.config/git/work

hasconfig:remote.*.url:

[includeIf "hasconfig:remote.*.url:git@github.com:*/**"]
path = ~/.config/git/config-gh
[includeIf "hasconfig:remote.*.url:git@github.com:orgname/**"]
path = ~/.config/git/config-gh-org
[includeIf "hasconfig:remote.*.url:git@gitlab.com:*/**"]
path = ~/.config/git/config-gl
[includeIf "hasconfig:remote.*.url:git@git.sr.ht:*/**"]
path = ~/.config/git/config-srht

insteadOf

[url "gh-work:orgname"]
insteadOf = git@github.com:orgname

Speeding up the Rust edit-build-run cycle

Mon, 18 Nov 2024 09:10:54 +0800

Speeding up the Rust edit-build-run cycle

Mac Niche App Recommendations and Workflow Share (2024)

Thu, 14 Nov 2024 09:52:00 +0800

Mac Niche App Recommendations and Workflow Share (2024)

Objective-See: An Open Source Project Org for Apple Privacy and Security

Wed, 13 Nov 2024 09:44:00 +0800

Objective-See: An Open Source Project Org for Apple Privacy and Security

While searching for small tools today, I found they have built a bunch of open-source software for macOS, mostly related to privacy and security.

KnockKnock: See what background processes, daemons, launch items, kernel extensions, login items, browser plugins, and more are on your Mac. Much more detailed than “Login Items” (some software auto-starts in other ways).
LuLu: An open-source macOS network firewall that lets you control each application’s network connections in detail (similar to Hands Off!).

Advanced macOS Command-Line Tools

Wed, 13 Nov 2024 09:14:26 +0800

sips - image manipulation

sips -z <height> <width> <image> resizes the specified image, ignoring the previous aspect ratio.

sips -Z <size> <image> resizes the largest side of the specified image, preserving the aspect ratio.

sips -c <height> <width> <image> crops the specified image to the given dimensions (relative to the center of the original image).

sips -r <degrees> <image> rotates the image by the specified degrees.

Sharpen the Axe Before Cutting Wood: My Home Network Setup

Mon, 11 Nov 2024 09:25:57 +0800

Sharpen the Axe Before Cutting Wood: My Home Network Setup

Convert Cloudflare WARP to an HTTP Proxy

Wed, 06 Nov 2024 17:47:06 +0800

Convert Cloudflare WARP to an HTTP Proxy

warp-cli proxy port 60606
warp-cli mode proxy

However, Go programs do not support SOCKS proxies, and I don’t want to manually add a transport.

The good news is that Go respects the http_proxy environment variable by default. So we need to convert the SOCKS proxy to an HTTP proxy.

pproxy -v -l http://127.0.0.1:8118 -r socks5://127.0.0.1:60606

https_proxy=http://127.0.0.1:8118 http_proxy=http://127.0.0.1:8118 curl ipv4.win
curl: (52) Empty reply from server

# pproxy logs
Serving on ipv? 127.0.0.1:8118 by http
http 127.0.0.1:45012 -> socks5 127.0.0.1:60606 -> ipv4.win:80
Unknown remote protocol from 127.0.0.1

Maybe it’s a pproxy issue, so try gost.

Relay V2Ray Traffic via Cloudflare

Tue, 22 Oct 2024 09:24:08 +0800

Install Script

bash <(wget -qO- -o- https://git.io/v2ray.sh)

Preparation

Add a DNS record now. Name: ai, IPv4 address: your VPS IP. The proxy status must be off, so the cloud icon is gray.

Tip: You can use v2ray ip to view your VPS IP.

Add Relay Configuration

Use v2ray add ws ai.233boy.com to add a vmess-ws-tls configuration; remember to replace ai.233boy.com with your domain.

Advanced Shell Scripting Techniques: Automating Complex Tasks with Bash

Wed, 25 Sep 2024 09:23:00 +0800

Advanced Shell Scripting Techniques: Automating Complex Tasks with Bash

Use Built-in Commands

Built-in commands execute faster because they don’t require loading an external process.

Minimize Subshells

Subshells can be expensive in terms of performance.

# Inefficient
output=$(cat file.txt)

# Efficient
output=$(<file.txt)

Use Arrays for Bulk Data

When handling a large amount of data, arrays can be more efficient and easier to manage than multiple variables.

# Inefficient
item1="apple"
item2="banana"
item3="cherry"

# Efficient
items=("apple" "banana" "cherry")
for item in "${items[@]}"; do
 echo "$item"
done

Enable Noclobber

To prevent accidental overwriting of files.

set -o noclobber

Use Functions

Functions allow you to encapsulate and reuse code, making scripts cleaner and reducing redundancy.

Efficient File Operations

When performing file operations, use efficient techniques to minimize resource usage.

# Inefficient
while read -r line; do
 echo "$line"
done < file.txt

# Efficient
while IFS= read -r line; do
 echo "$line"
done < file.txt

Parallel Processing

Tools like xargs and GNU parallel can be incredibly useful.

Error Handling

Robust error handling is critical for creating reliable and maintainable scripts.

# Exit on Error: Using set -e ensures that your script exits immediately if any command fails, preventing cascading errors.
set -e

# Custom Error Messages: Implement custom error messages to provide more context when something goes wrong.
command1 || { echo "command1 failed"; exit 1; }

# Trap Signals: Use the `trap` command to catch and handle signals and errors gracefully.
trap 'echo "Error occurred"; cleanup; exit 1' ERR

function cleanup() {
 # Cleanup code
}

# Validate Inputs: Always validate user inputs and script arguments to prevent unexpected behavior.
if [[ -z "$1" ]]; then
 echo "Usage: $0 <argument>"
 exit 1
fi

# Logging: Implement logging to keep track of script execution and diagnose issues.
logfile="script.log"
exec > >(tee -i $logfile)
exec 2>&1

echo "Script started"

Automating Complex System Administration Tasks:

Automated Backups
System Monitoring
User Management
Automated Updates
Network Configuration

Google Infra

Tue, 24 Sep 2024 09:04:00 +0800

Google’s 5-generation network architecture in ten years

Supply chain attack

Fri, 13 Sep 2024 09:41:00 +0800

Be Alert: Supply Chain Attacks Are Closer Than You Think

github.com/siruspen/logrus false
github.com/sirupsen/logrus true

Lightweight Linux Distributions For Older PCs

Tue, 20 Aug 2024 12:38:00 +0800

lightweight-linux-distributions-for-your-pc

Name	Site	Comment
Puppy Linux	https://puppylinux-woof-ce.github.io/	This tiny OS weighs in at under 300MB, so it can run smoothly even on systems with as little as 512MB of RAM.
Bodhi Linux	https://www.bodhilinux.com/	System requirements are just 512MB of RAM and a 500MHz processor.
Peppermint OS	https://peppermintos.com/	It only needs 512MB of RAM to run, so it will fly on that Pentium 4 machine or Core 2 Duo laptop you have stashed in your closet. While Peppermint OS is light on local resources, it integrates well with cloud and web apps. The OS builds in close integration with services like Dropbox, Google Drive, and more.
AntiX	https://antixlinux.com/	AntiX is designed to run on systems with as little as 64MB of RAM and a Pentium II processor.
Lubuntu	https://lubuntu.me/	Lubuntu will run smoothly on computers with as little as 512 MB of RAM and a 1 GHz processor.

Go Articles

Tue, 20 Aug 2024 08:55:00 +0800

Learn gin Parameter Validation with the validator Library - This One Article Is Enough

String Constraints

excludesall: does not contain any of the UNICODE characters in the parameter, e.g. excludesall=ab

excludesrune: does not contain the rune specified by the parameter, e.g. excludesrune=asong

startswith: starts with the parameter substring, e.g. startswith=hi

endswith: ends with the parameter substring, e.g. endswith=bye

contains: contains the parameter substring, e.g. contains=email

containsany: contains any of the UNICODE characters in the parameter, e.g. containsany=ab

Build a Private Object Storage with Traefik v3 and MinIO in Docker

Tue, 06 Aug 2024 12:26:26 +0800

Makefiles for Web Projects: Manage Your Environment Workflow

Mon, 05 Aug 2024 17:21:24 +0800

Note: Makefile indentation must use tabs, otherwise you’ll get syntax errors.

The Core of a Makefile: Targets

up:
 cp .env.example .env
 docker compose up -d workspace

stop:
 docker compose stop

zsh:
 docker compose exec workspace zsh

This example has three targets: up, stop, and zsh. By default, Make treats the first target as the Goal (it cannot start with a dot), which is the project’s primary workflow. In this case, make and make up do the same thing.
But the copy step above is not a typical Make use case. Make shines at deciding whether each target needs to run. For example, we often store secrets in .env. If .env already exists, we shouldn’t overwrite it by copying .env.example again. In that case, we can make .env a target:

up: .env
 docker compose up -d workspace

.env:
 cp .env.example .env

By default, target names are treated as filenames. The name “make” implies building a target; it will only execute the target’s recipe when the conditions are met (like the file not existing).
- In this example, when you run the up target, if .env doesn’t exist it will run the .env target first to create it, then start the workspace container. If .env already exists, it skips the .env target and starts the container directly.
- Likewise, if there is a file named up in the directory, the up target won’t run. You can define Phony Targets to tell Make that certain targets aren’t filenames, but named workflows instead:

.PHONY: up stop zsh

Add Some Variables

Make supports variables (Variable). Following common Unix environment variable conventions, we usually write them in SCREAMING_SNAKE_CASE. When used, variables are wrapped in $().

Black Hat Go

Thu, 01 Aug 2024 15:10:22 +0800

Hide Within Cloudflare's Global Network

Thu, 01 Aug 2024 14:35:24 +0800

Hide Within Cloudflare’s Global Network

One approach is to use Cloudflare WARP, running WARP in proxy mode instead of taking over global traffic.

warp-cli register
# WARP listens on local port 11111
warp-cli set-proxy-port 11111

# WARP proxy mode
warp-cli set-mode proxy

# Always on
warp-cli enable-always-on

https_proxy=socks5://127.0.0.1:11111 http_proxy=socks5://127.0.0.1:11111 go run main.go

Another approach is to use Cloudflare Workers, with requests forwarded by Workers.

export default {
 async fetch(request: Request): Promise {
 /**
 * Replace `remote` with the host you wish to send requests to
 */
 const remote = "https://example.com";

 return await fetch(remote, request);
 },
};

Git force push

Fri, 26 Jul 2024 12:24:00 +0800

git push --force-with-lease

Illustrating How Data Alignment Affects Memory Usage in Go

Mon, 08 Jul 2024 17:52:37 +0800

Illustrating How Data Alignment Affects Memory Usage in Go

The One Billion Row Challenge in Go: from 1m45s to 3.4s in nine solutions

Mon, 08 Jul 2024 09:50:10 +0800

Baseline

$ time cat measurements.txt >/dev/null
0m1.052s

$ time wc measurements.txt
 1000000000 1179173106 13795293380 measurements.txt
0m55.710s

$ time gawk -b -f 1brc.awk measurements.txt >measurements.out
7m35.567s

BEGIN {
 FS = ";"
}

{
 if (counts[$1]++) {
 mins[$1] = $2 < mins[$1] ? $2 : mins[$1]
 maxs[$1] = $2 > maxs[$1] ? $2 : maxs[$1]
 } else {
 mins[$1] = maxs[$1] = $2 # new entry
 }
 sums[$1] += $2
}

END {
 printf "{"
 n = asorti(mins, sorted)
 for (i = 1; i <= n; i++) {
 station = sorted[i]
 min = mins[station]
 max = maxs[station]
 mean = sums[station] / counts[station]
 printf "%s=%.1f/%.1f/%.1f", station, min, mean, max
 if (i < n) {
 printf ", "
 }
 }
 printf "}\n"
}

Solution 1: simple and idiomatic Go

// r1: simple, idiomatic Go using bufio.Scanner and strconv.ParseFloat
//
// ~1.004s for 10M rows

package main

import (
 "bufio"
 "fmt"
 "io"
 "os"
 "sort"
 "strconv"
 "strings"
)

func r1(inputPath string, output io.Writer) error {
 type stats struct {
 min, max, sum float64
 count int64
 }

 f, err := os.Open(inputPath)
 if err != nil {
 return err
 }
 defer f.Close()

 stationStats := make(map[string]stats)

 scanner := bufio.NewScanner(f)
 for scanner.Scan() {
 line := scanner.Text()
 station, tempStr, hasSemi := strings.Cut(line, ";")
 if !hasSemi {
 continue
 }

 temp, err := strconv.ParseFloat(tempStr, 64)
 if err != nil {
 return err
 }

 s, ok := stationStats[station]
 if !ok {
 s.min = temp
 s.max = temp
 s.sum = temp
 s.count = 1
 } else {
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += temp
 s.count++
 }
 stationStats[station] = s
 }

 stations := make([]string, 0, len(stationStats))
 for station := range stationStats {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := stationStats[station]
 mean := s.sum / float64(s.count)
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, s.min, mean, s.max)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

Solution 2: map with pointer values

// r2: use stats pointer as map value to avoid double hashing
//
// ~921ms for 10M rows (1.09x as fast as r1)

package main

import (
 "bufio"
 "fmt"
 "io"
 "os"
 "sort"
 "strconv"
 "strings"
)

func r2(inputPath string, output io.Writer) error {
 type stats struct {
 min, max, sum float64
 count int64
 }

 f, err := os.Open(inputPath)
 if err != nil {
 return err
 }
 defer f.Close()

 stationStats := make(map[string]*stats)

 scanner := bufio.NewScanner(f)
 for scanner.Scan() {
 line := scanner.Text()
 station, tempStr, hasSemi := strings.Cut(line, ";")
 if !hasSemi {
 continue
 }

 temp, err := strconv.ParseFloat(tempStr, 64)
 if err != nil {
 return err
 }

 s := stationStats[station]
 if s == nil {
 stationStats[station] = &stats{
 min: temp,
 max: temp,
 sum: temp,
 count: 1,
 }
 } else {
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += temp
 s.count++
 }
 }

 stations := make([]string, 0, len(stationStats))
 for station := range stationStats {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := stationStats[station]
 mean := s.sum / float64(s.count)
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, s.min, mean, s.max)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

Solution 3: avoid strconv.ParseFloat

// r3: parse temperatures manually instead of using strconv.ParseFloat
//
// ~517ms for 10M rows (1.94x as fast as r1)

package main

import (
 "bufio"
 "bytes"
 "fmt"
 "io"
 "os"
 "sort"
)

func r3(inputPath string, output io.Writer) error {
 type stats struct {
 min, max, sum float64
 count int64
 }

 f, err := os.Open(inputPath)
 if err != nil {
 return err
 }
 defer f.Close()

 stationStats := make(map[string]*stats)

 scanner := bufio.NewScanner(f)
 for scanner.Scan() {
 line := scanner.Bytes()
 station, tempBytes, hasSemi := bytes.Cut(line, []byte(";"))
 if !hasSemi {
 continue
 }

 negative := false
 index := 0
 if tempBytes[index] == '-' {
 index++
 negative = true
 }
 temp := float64(tempBytes[index] - '0')
 index++
 if tempBytes[index] != '.' {
 temp = temp*10 + float64(tempBytes[index]-'0')
 index++
 }
 index++ // skip '.'
 temp += float64(tempBytes[index]-'0') / 10
 if negative {
 temp = -temp
 }

 s := stationStats[string(station)]
 if s == nil {
 stationStats[string(station)] = &stats{
 min: temp,
 max: temp,
 sum: temp,
 count: 1,
 }
 } else {
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += temp
 s.count++
 }
 }

 stations := make([]string, 0, len(stationStats))
 for station := range stationStats {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := stationStats[station]
 mean := s.sum / float64(s.count)
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, s.min, mean, s.max)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

Solution 4: fixed point integers

// r4: use fixed point int32s (*10) instead of float64s
//
// ~491ms for 10M rows (2.04x as fast as r1)

package main

import (
 "bufio"
 "bytes"
 "fmt"
 "io"
 "os"
 "sort"
)

func r4(inputPath string, output io.Writer) error {
 type stats struct {
 min, max, count int32
 sum int64
 }

 f, err := os.Open(inputPath)
 if err != nil {
 return err
 }
 defer f.Close()

 stationStats := make(map[string]*stats)

 scanner := bufio.NewScanner(f)
 for scanner.Scan() {
 line := scanner.Bytes()
 station, tempBytes, hasSemi := bytes.Cut(line, []byte(";"))
 if !hasSemi {
 continue
 }

 negative := false
 index := 0
 if tempBytes[index] == '-' {
 index++
 negative = true
 }
 temp := int32(tempBytes[index] - '0')
 index++
 if tempBytes[index] != '.' {
 temp = temp*10 + int32(tempBytes[index]-'0')
 index++
 }
 index++ // skip '.'
 temp = temp*10 + int32(tempBytes[index]-'0')
 if negative {
 temp = -temp
 }

 s := stationStats[string(station)]
 if s == nil {
 stationStats[string(station)] = &stats{
 min: temp,
 max: temp,
 sum: int64(temp),
 count: 1,
 }
 } else {
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += int64(temp)
 s.count++
 }
 }

 stations := make([]string, 0, len(stationStats))
 for station := range stationStats {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := stationStats[station]
 mean := float64(s.sum) / float64(s.count) / 10
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, float64(s.min)/10, mean, float64(s.max)/10)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

Solution 5: avoid bytes.Cut

// r5: avoid bytes.Cut
//
// ~442ms for 10M rows (2.27x as fast as r1)

package main

import (
 "bufio"
 "fmt"
 "io"
 "os"
 "sort"
)

func r5(inputPath string, output io.Writer) error {
 type stats struct {
 min, max, count int32
 sum int64
 }

 f, err := os.Open(inputPath)
 if err != nil {
 return err
 }
 defer f.Close()

 stationStats := make(map[string]*stats)

 scanner := bufio.NewScanner(f)
 for scanner.Scan() {
 line := scanner.Bytes()

 end := len(line)
 tenths := int32(line[end-1] - '0')
 ones := int32(line[end-3] - '0') // line[end-2] is '.'
 var temp int32
 var semicolon int
 if line[end-4] == ';' {
 temp = ones*10 + tenths
 semicolon = end - 4
 } else if line[end-4] == '-' {
 temp = -(ones*10 + tenths)
 semicolon = end - 5
 } else {
 tens := int32(line[end-4] - '0')
 if line[end-5] == ';' {
 temp = tens*100 + ones*10 + tenths
 semicolon = end - 5
 } else { // '-'
 temp = -(tens*100 + ones*10 + tenths)
 semicolon = end - 6
 }
 }

 station := line[:semicolon]
 s := stationStats[string(station)]
 if s == nil {
 stationStats[string(station)] = &stats{
 min: temp,
 max: temp,
 sum: int64(temp),
 count: 1,
 }
 } else {
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += int64(temp)
 s.count++
 }
 }

 stations := make([]string, 0, len(stationStats))
 for station := range stationStats {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := stationStats[station]
 mean := float64(s.sum) / float64(s.count) / 10
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, float64(s.min)/10, mean, float64(s.max)/10)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

Solution 6: avoid bufio.Scanner

// r6: don't use bufio.Scanner to avoid scanning some bytes twice
//
// ~399ms for 10M rows (2.52x as fast as r1)

package main

import (
 "bytes"
 "fmt"
 "io"
 "os"
 "sort"
)

func r6(inputPath string, output io.Writer) error {
 type stats struct {
 min, max, count int32
 sum int64
 }

 f, err := os.Open(inputPath)
 if err != nil {
 return err
 }
 defer f.Close()

 stationStats := make(map[string]*stats)

 buf := make([]byte, 1024*1024)
 readStart := 0
 for {
 n, err := f.Read(buf[readStart:])
 if err != nil && err != io.EOF {
 return err
 }
 if readStart+n == 0 {
 break
 }
 chunk := buf[:readStart+n]

 newline := bytes.LastIndexByte(chunk, '\n')
 if newline < 0 {
 break
 }
 remaining := chunk[newline+1:]
 chunk = chunk[:newline+1]

 for {
 station, after, hasSemi := bytes.Cut(chunk, []byte(";"))
 if !hasSemi {
 break
 }

 index := 0
 negative := false
 if after[index] == '-' {
 negative = true
 index++
 }
 temp := int32(after[index] - '0')
 index++
 if after[index] != '.' {
 temp = temp*10 + int32(after[index]-'0')
 index++
 }
 index++ // skip '.'
 temp = temp*10 + int32(after[index]-'0')
 index += 2 // skip last digit and '\n'
 if negative {
 temp = -temp
 }
 chunk = after[index:]

 s := stationStats[string(station)]
 if s == nil {
 stationStats[string(station)] = &stats{
 min: temp,
 max: temp,
 sum: int64(temp),
 count: 1,
 }
 } else {
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += int64(temp)
 s.count++
 }
 }

 readStart = copy(buf, remaining)
 }

 stations := make([]string, 0, len(stationStats))
 for station := range stationStats {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := stationStats[station]
 mean := float64(s.sum) / float64(s.count) / 10
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, float64(s.min)/10, mean, float64(s.max)/10)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

Solution 7: custom hash table

// r7: use custom hash table and hash station name as we look for ';'
//
// ~234ms for 10M rows (4.29x as fast as r1)

package main

import (
 "bytes"
 "fmt"
 "io"
 "os"
 "sort"
)

func r7(inputPath string, output io.Writer) error {
 type stats struct {
 min, max, count int32
 sum int64
 }

 f, err := os.Open(inputPath)
 if err != nil {
 return err
 }
 defer f.Close()

 type item struct {
 key []byte
 stat *stats
 }
 const numBuckets = 1 << 17 // number of hash buckets (power of 2)
 items := make([]item, numBuckets) // hash buckets, linearly probed
 size := 0 // number of active items in items slice

 buf := make([]byte, 1024*1024)
 readStart := 0
 for {
 n, err := f.Read(buf[readStart:])
 if err != nil && err != io.EOF {
 return err
 }
 if readStart+n == 0 {
 break
 }
 chunk := buf[:readStart+n]

 newline := bytes.LastIndexByte(chunk, '\n')
 if newline < 0 {
 break
 }
 remaining := chunk[newline+1:]
 chunk = chunk[:newline+1]

 for {
 const (
 // FNV-1 64-bit constants from hash/fnv.
 offset64 = 14695981039346656037
 prime64 = 1099511628211
 )

 var station, after []byte
 hash := uint64(offset64)
 i := 0
 for ; i < len(chunk); i++ {
 c := chunk[i]
 if c == ';' {
 station = chunk[:i]
 after = chunk[i+1:]
 break
 }
 hash ^= uint64(c) // FNV-1a is XOR then *
 hash *= prime64
 }
 if i == len(chunk) {
 break
 }

 index := 0
 negative := false
 if after[index] == '-' {
 negative = true
 index++
 }
 temp := int32(after[index] - '0')
 index++
 if after[index] != '.' {
 temp = temp*10 + int32(after[index]-'0')
 index++
 }
 index++ // skip '.'
 temp = temp*10 + int32(after[index]-'0')
 index += 2 // skip last digit and '\n'
 if negative {
 temp = -temp
 }
 chunk = after[index:]

 hashIndex := int(hash & uint64(numBuckets-1))
 for {
 if items[hashIndex].key == nil {
 // Found empty slot, add new item (copying key).
 key := make([]byte, len(station))
 copy(key, station)
 items[hashIndex] = item{
 key: key,
 stat: &stats{
 min: temp,
 max: temp,
 sum: int64(temp),
 count: 1,
 },
 }
 size++
 if size > numBuckets/2 {
 panic("too many items in hash table")
 }
 break
 }
 if bytes.Equal(items[hashIndex].key, station) {
 // Found matching slot, add to existing stats.
 s := items[hashIndex].stat
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += int64(temp)
 s.count++
 break
 }
 // Slot already holds another key, try next slot (linear probe).
 hashIndex++
 if hashIndex >= numBuckets {
 hashIndex = 0
 }
 }
 }

 readStart = copy(buf, remaining)
 }

 stationItems := make([]item, 0, size)
 for _, item := range items {
 if item.key == nil {
 continue
 }
 stationItems = append(stationItems, item)
 }
 sort.Slice(stationItems, func(i, j int) bool {
 return string(stationItems[i].key) < string(stationItems[j].key)
 })

 fmt.Fprint(output, "{")
 for i, item := range stationItems {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := item.stat
 mean := float64(s.sum) / float64(s.count) / 10
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", item.key, float64(s.min)/10, mean, float64(s.max)/10)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

Solution 8: process chunks in parallel

// r8: add some parallelism (but back to non-optimized r1 version)
//
// ~213ms for 10M rows (4.71x as fast as r1)

package main

import (
 "bufio"
 "bytes"
 "fmt"
 "io"
 "os"
 "sort"
 "strconv"
 "strings"
)

type r8Stats struct {
 min, max, sum float64
 count int64
}

func r8(inputPath string, output io.Writer) error {
 parts, err := splitFile(inputPath, maxGoroutines)
 if err != nil {
 return err
 }

 resultsCh := make(chan map[string]r8Stats)
 for _, part := range parts {
 go r8ProcessPart(inputPath, part.offset, part.size, resultsCh)
 }

 totals := make(map[string]r8Stats)
 for i := 0; i < len(parts); i++ {
 result := <-resultsCh
 for station, s := range result {
 ts, ok := totals[station]
 if !ok {
 totals[station] = r8Stats{
 min: s.min,
 max: s.max,
 sum: s.sum,
 count: s.count,
 }
 continue
 }
 ts.min = min(ts.min, s.min)
 ts.max = max(ts.max, s.max)
 ts.sum += s.sum
 ts.count += s.count
 totals[station] = ts
 }
 }

 stations := make([]string, 0, len(totals))
 for station := range totals {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := totals[station]
 mean := s.sum / float64(s.count)
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, s.min, mean, s.max)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

func r8ProcessPart(inputPath string, fileOffset, fileSize int64, resultsCh chan map[string]r8Stats) {
 file, err := os.Open(inputPath)
 if err != nil {
 panic(err)
 }
 defer file.Close()
 _, err = file.Seek(fileOffset, io.SeekStart)
 if err != nil {
 panic(err)
 }
 f := io.LimitedReader{R: file, N: fileSize}

 stationStats := make(map[string]r8Stats)

 scanner := bufio.NewScanner(&f)
 for scanner.Scan() {
 line := scanner.Text()
 station, tempStr, hasSemi := strings.Cut(line, ";")
 if !hasSemi {
 continue
 }

 temp, err := strconv.ParseFloat(tempStr, 64)
 if err != nil {
 panic(err)
 }

 s, ok := stationStats[station]
 if !ok {
 s.min = temp
 s.max = temp
 s.sum = temp
 s.count = 1
 } else {
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += temp
 s.count++
 }
 stationStats[station] = s
 }

 resultsCh <- stationStats
}

type part struct {
 offset, size int64
}

func splitFile(inputPath string, numParts int) ([]part, error) {
 const maxLineLength = 100

 f, err := os.Open(inputPath)
 if err != nil {
 return nil, err
 }
 st, err := f.Stat()
 if err != nil {
 return nil, err
 }
 size := st.Size()
 splitSize := size / int64(numParts)

 buf := make([]byte, maxLineLength)

 parts := make([]part, 0, numParts)
 offset := int64(0)
 for i := 0; i < numParts; i++ {
 if i == numParts-1 {
 if offset < size {
 parts = append(parts, part{offset, size - offset})
 }
 break
 }

 seekOffset := max(offset+splitSize-maxLineLength, 0)
 _, err := f.Seek(seekOffset, io.SeekStart)
 if err != nil {
 return nil, err
 }
 n, _ := io.ReadFull(f, buf)
 chunk := buf[:n]
 newline := bytes.LastIndexByte(chunk, '\n')
 if newline < 0 {
 return nil, fmt.Errorf("newline not found at offset %d", offset+splitSize-maxLineLength)
 }
 remaining := len(chunk) - newline - 1
 nextOffset := seekOffset + int64(len(chunk)) - int64(remaining)
 parts = append(parts, part{offset, nextOffset - offset})
 offset = nextOffset
 }
 return parts, nil
}

Solution 9: all optimisations plus parallelisation

// r9: all the previous optimizations plus parallel execution
//
// 43ms for 10M rows (23.3x as fast as r1)

package main

import (
 "bytes"
 "fmt"
 "io"
 "os"
 "sort"
)

type r9Stats struct {
 min, max, count int32
 sum int64
}

func r9(inputPath string, output io.Writer) error {
 parts, err := splitFile(inputPath, maxGoroutines)
 if err != nil {
 return err
 }

 resultsCh := make(chan map[string]*r9Stats)
 for _, part := range parts {
 go r9ProcessPart(inputPath, part.offset, part.size, resultsCh)
 }

 totals := make(map[string]*r9Stats)
 for i := 0; i < len(parts); i++ {
 result := <-resultsCh
 for station, s := range result {
 ts := totals[station]
 if ts == nil {
 totals[station] = s
 continue
 }
 ts.min = min(ts.min, s.min)
 ts.max = max(ts.max, s.max)
 ts.sum += s.sum
 ts.count += s.count
 }
 }

 stations := make([]string, 0, len(totals))
 for station := range totals {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := totals[station]
 mean := float64(s.sum) / float64(s.count) / 10
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, float64(s.min)/10, mean, float64(s.max)/10)
 }
 fmt.Fprint(output, "}\n")
 return nil
}

func r9ProcessPart(inputPath string, fileOffset, fileSize int64, resultsCh chan map[string]*r9Stats) {
 file, err := os.Open(inputPath)
 if err != nil {
 panic(err)
 }
 defer file.Close()
 _, err = file.Seek(fileOffset, io.SeekStart)
 if err != nil {
 panic(err)
 }
 f := io.LimitedReader{R: file, N: fileSize}

 type item struct {
 key []byte
 stat *r9Stats
 }
 const numBuckets = 1 << 17 // number of hash buckets (power of 2)
 items := make([]item, numBuckets) // hash buckets, linearly probed
 size := 0 // number of active items in items slice

 buf := make([]byte, 1024*1024)
 readStart := 0
 for {
 n, err := f.Read(buf[readStart:])
 if err != nil && err != io.EOF {
 panic(err)
 }
 if readStart+n == 0 {
 break
 }
 chunk := buf[:readStart+n]

 newline := bytes.LastIndexByte(chunk, '\n')
 if newline < 0 {
 break
 }
 remaining := chunk[newline+1:]
 chunk = chunk[:newline+1]

 for {
 const (
 // FNV-1 64-bit constants from hash/fnv.
 offset64 = 14695981039346656037
 prime64 = 1099511628211
 )

 var station, after []byte
 hash := uint64(offset64)
 i := 0
 for ; i < len(chunk); i++ {
 c := chunk[i]
 if c == ';' {
 station = chunk[:i]
 after = chunk[i+1:]
 break
 }
 hash ^= uint64(c) // FNV-1a is XOR then *
 hash *= prime64
 }
 if i == len(chunk) {
 break
 }

 index := 0
 negative := false
 if after[index] == '-' {
 negative = true
 index++
 }
 temp := int32(after[index] - '0')
 index++
 if after[index] != '.' {
 temp = temp*10 + int32(after[index]-'0')
 index++
 }
 index++ // skip '.'
 temp = temp*10 + int32(after[index]-'0')
 index += 2 // skip last digit and '\n'
 if negative {
 temp = -temp
 }
 chunk = after[index:]

 hashIndex := int(hash & (numBuckets - 1))
 for {
 if items[hashIndex].key == nil {
 // Found empty slot, add new item (copying key).
 key := make([]byte, len(station))
 copy(key, station)
 items[hashIndex] = item{
 key: key,
 stat: &r9Stats{
 min: temp,
 max: temp,
 sum: int64(temp),
 count: 1,
 },
 }
 size++
 if size > numBuckets/2 {
 panic("too many items in hash table")
 }
 break
 }
 if bytes.Equal(items[hashIndex].key, station) {
 // Found matching slot, add to existing stats.
 s := items[hashIndex].stat
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += int64(temp)
 s.count++
 break
 }
 // Slot already holds another key, try next slot (linear probe).
 hashIndex++
 if hashIndex >= numBuckets {
 hashIndex = 0
 }
 }
 }

 readStart = copy(buf, remaining)
 }

 result := make(map[string]*r9Stats, size)
 for _, item := range items {
 if item.key == nil {
 continue
 }
 result[string(item.key)] = item.stat
 }
 resultsCh <- result
}

Solution 10: all the previous optimizations plus faster semicolon finding and hashing

// r10: all the previous optimizations plus faster semicolon finding and
// hashing
//
// Translated from Java by Menno Finlay-Smits Ideas with ideas taken from
// this fast Java solution:
//
// https://github.com/gunnarmorling/1brc/blob/main/src/main/java/dev/morling/onebrc/CalculateAverage_mtopolnik.java
//
// On my (Ben's) laptop I get these initial results:
//
// $ ./go-1brc -revision=1 ../1brc/data/measurements.txt >out-r1
// Processed 13156.2MB in 1m39.507011009s
// $ ./go-1brc -revision=9 ../1brc/data/measurements.txt >out-r9
// Processed 13156.2MB in 2.893693843s # 34.4x as fast as the r1 above
// $ ./go-1brc -revision=10 ../1brc/data/measurements.txt >out-r10
// Processed 13156.2MB in 2.497241029s # 39.8x as fast as the r1 above

package main

import (
 "bytes"
 "encoding/binary"
 "fmt"
 "io"
 "math/bits"
 "os"
 "sort"
)

const BroadcastSemicolon = 0x3B3B3B3B3B3B3B3B
const Broadcast0x01 = 0x0101010101010101
const Broadcast0x80 = 0x8080808080808080

type r10Stats struct {
 min, max, count int32
 sum int64
}

func r10(inputPath string, output io.Writer) error {
 parts, err := splitFile(inputPath, maxGoroutines)
 if err != nil {
 return err
 }

 resultsCh := make(chan map[string]*r10Stats)
 for _, part := range parts {
 go r10ProcessPart(inputPath, part.offset, part.size, resultsCh)
 }

 totals := make(map[string]*r10Stats)
 for i := 0; i < len(parts); i++ {
 result := <-resultsCh
 for station, s := range result {
 ts := totals[station]
 if ts == nil {
 totals[station] = s
 continue
 }
 ts.min = min(ts.min, s.min)
 ts.max = max(ts.max, s.max)
 ts.sum += s.sum
 ts.count += s.count
 }
 }

 stations := make([]string, 0, len(totals))
 for station := range totals {
 stations = append(stations, station)
 }
 sort.Strings(stations)

 fmt.Fprint(output, "{")
 for i, station := range stations {
 if i > 0 {
 fmt.Fprint(output, ", ")
 }
 s := totals[station]
 mean := float64(s.sum) / float64(s.count) / 10
 fmt.Fprintf(output, "%s=%.1f/%.1f/%.1f", station, float64(s.min)/10, mean, float64(s.max)/10)
 }
 fmt.Fprint(output, "}\n")

 return nil
}

func r10ProcessPart(inputPath string, fileOffset, fileSize int64, resultsCh chan map[string]*r10Stats) {
 file, err := os.Open(inputPath)
 if err != nil {
 panic(err)
 }
 defer file.Close()
 _, err = file.Seek(fileOffset, io.SeekStart)
 if err != nil {
 panic(err)
 }
 f := io.LimitedReader{R: file, N: fileSize}

 type item struct {
 key []byte
 stat *r10Stats
 }
 const numBuckets = 1 << 17 // number of hash buckets (power of 2)
 items := make([]item, numBuckets) // hash buckets, linearly probed
 size := 0 // number of active items in items slice

 buf := make([]byte, 1024*1024)
 readStart := 0
 for {
 n, err := f.Read(buf[readStart:])
 if err != nil && err != io.EOF {
 panic(err)
 }
 if readStart+n == 0 {
 break
 }
 chunk := buf[:readStart+n]

 newline := bytes.LastIndexByte(chunk, '\n')
 if newline < 0 {
 break
 }
 remaining := chunk[newline+1:]
 chunk = chunk[:newline+1]

 chunkLoop:
 for {
 var hash uint64
 var station, after []byte

 if len(chunk) < 8 {
 break chunkLoop
 }

 nameWord0 := binary.NativeEndian.Uint64(chunk)
 matchBits := semicolonMatchBits(nameWord0)
 if matchBits != 0 {
 // semicolon is in the first 8 bytes
 nameLen := calcNameLen(matchBits)
 nameWord0 = maskWord(nameWord0, matchBits)
 station = chunk[:nameLen]
 after = chunk[nameLen+1:]
 hash = calcHash(nameWord0)
 } else {
 // station name is longer so keep looking for the semicolon in
 // uint64 chunks
 nameLen := 8
 hash = calcHash(nameWord0)
 for {
 if nameLen > len(chunk)-8 {
 break chunkLoop
 }
 lastNameWord := binary.NativeEndian.Uint64(chunk[nameLen:])
 matchBits = semicolonMatchBits(lastNameWord)
 if matchBits != 0 {
 nameLen += calcNameLen(matchBits)
 station = chunk[:nameLen]
 after = chunk[nameLen+1:]
 break
 }
 nameLen += 8
 }
 }
 index := 0
 negative := false
 if after[index] == '-' {
 negative = true
 index++
 }
 temp := int32(after[index] - '0')
 index++
 if after[index] != '.' {
 temp = temp*10 + int32(after[index]-'0')
 index++
 }
 index++ // skip '.'
 temp = temp*10 + int32(after[index]-'0')
 index += 2 // skip last digit and '\n'
 if negative {
 temp = -temp
 }
 chunk = after[index:]

 hashIndex := int(hash & (numBuckets - 1))
 for {
 if items[hashIndex].key == nil {
 // Found empty slot, add new item (copying key).
 key := make([]byte, len(station))
 copy(key, station)
 items[hashIndex] = item{
 key: key,
 stat: &r10Stats{
 min: temp,
 max: temp,
 sum: int64(temp),
 count: 1,
 },
 }
 size++
 if size > numBuckets/2 {
 panic("too many items in hash table")
 }
 break
 }
 if bytes.Equal(items[hashIndex].key, station) {
 // Found matching slot, add to existing stats.
 s := items[hashIndex].stat
 s.min = min(s.min, temp)
 s.max = max(s.max, temp)
 s.sum += int64(temp)
 s.count++
 break
 }
 // Slot already holds another key, try next slot (linear probe).
 hashIndex++
 if hashIndex >= numBuckets {
 hashIndex = 0
 }
 }
 }

 readStart = copy(buf, remaining)
 }

 result := make(map[string]*r10Stats, size)
 for _, item := range items {
 if item.key == nil {
 continue
 }
 result[string(item.key)] = item.stat
 }
 resultsCh <- result
}

func calcNameLen(b uint64) int {
 return (bits.TrailingZeros64(b) >> 3)
}

func calcHash(word uint64) uint64 {
 return bits.RotateLeft64(word*0x51_7c_c1_b7_27_22_0a_95, 17)
}

func semicolonMatchBits(word uint64) uint64 {
 diff := word ^ BroadcastSemicolon
 return (diff - Broadcast0x01) & (^diff & Broadcast0x80)
}

func maskWord(word, matchBits uint64) uint64 {
 mask := matchBits ^ (matchBits - 1)
 return word & mask
}

Alexander Yastrebov

package main

import (
 "bytes"
 "fmt"
 "log"
 "math"
 "os"
 "runtime"
 "sort"
 "sync"
 "syscall"
)

type measurement struct {
 min, max, sum, count int64
}

func main() {
 if len(os.Args) != 2 {
 log.Fatalf("Missing measurements filename")
 }

 measurements := processFile(os.Args[1])

 ids := make([]string, 0, len(measurements))
 for id := range measurements {
 ids = append(ids, id)
 }
 sort.Strings(ids)

 fmt.Print("{")
 for i, id := range ids {
 if i > 0 {
 fmt.Print(", ")
 }
 m := measurements[id]
 fmt.Printf("%s=%.1f/%.1f/%.1f", id, round(float64(m.min)/10.0), round(float64(m.sum)/10.0/float64(m.count)), round(float64(m.max)/10.0))
 }
 fmt.Println("}")
}

func processFile(filename string) map[string]*measurement {
 f, err := os.Open(filename)
 if err != nil {
 log.Fatalf("Open: %v", err)
 }
 defer f.Close()

 fi, err := f.Stat()
 if err != nil {
 log.Fatalf("Stat: %v", err)
 }

 size := fi.Size()
 if size <= 0 || size != int64(int(size)) {
 log.Fatalf("Invalid file size: %d", size)
 }

 data, err := syscall.Mmap(int(f.Fd()), 0, int(size), syscall.PROT_READ, syscall.MAP_SHARED)
 if err != nil {
 log.Fatalf("Mmap: %v", err)
 }

 defer func() {
 if err := syscall.Munmap(data); err != nil {
 log.Fatalf("Munmap: %v", err)
 }
 }()

 return process(data)
}

func process(data []byte) map[string]*measurement {
 nChunks := runtime.NumCPU()

 chunkSize := len(data) / nChunks
 if chunkSize == 0 {
 chunkSize = len(data)
 }

 chunks := make([]int, 0, nChunks)
 offset := 0
 for offset < len(data) {
 offset += chunkSize
 if offset >= len(data) {
 chunks = append(chunks, len(data))
 break
 }

 nlPos := bytes.IndexByte(data[offset:], '\n')
 if nlPos == -1 {
 chunks = append(chunks, len(data))
 break
 } else {
 offset += nlPos + 1
 chunks = append(chunks, offset)
 }
 }

 var wg sync.WaitGroup
 wg.Add(len(chunks))

 results := make([]map[string]*measurement, len(chunks))
 start := 0
 for i, chunk := range chunks {
 go func(data []byte, i int) {
 results[i] = processChunk(data)
 wg.Done()
 }(data[start:chunk], i)
 start = chunk
 }
 wg.Wait()

 measurements := make(map[string]*measurement)
 for _, r := range results {
 for id, rm := range r {
 m := measurements[id]
 if m == nil {
 measurements[id] = rm
 } else {
 m.min = min(m.min, rm.min)
 m.max = max(m.max, rm.max)
 m.sum += rm.sum
 m.count += rm.count
 }
 }
 }
 return measurements
}

func processChunk(data []byte) map[string]*measurement {
 // Use fixed size linear probe lookup table
 const (
 // use power of 2 for fast modulo calculation,
 // should be larger than max number of keys which is 10_000
 entriesSize = 1 << 14

 // use FNV-1a hash
 fnv1aOffset64 = 14695981039346656037
 fnv1aPrime64 = 1099511628211
 )

 type entry struct {
 m measurement
 hash uint64
 vlen int
 value [128]byte // use power of 2 > 100 for alignment
 }
 entries := make([]entry, entriesSize)
 entriesCount := 0

 // keep short and inlinable
 getMeasurement := func(hash uint64, value []byte) *measurement {
 i := hash & uint64(entriesSize-1)
 entry := &entries[i]

 // bytes.Equal could be commented to speedup assuming no hash collisions
 for entry.vlen > 0 && !(entry.hash == hash && bytes.Equal(entry.value[:entry.vlen], value)) {
 i = (i + 1) & uint64(entriesSize-1)
 entry = &entries[i]
 }

 if entry.vlen == 0 {
 entry.hash = hash
 entry.vlen = copy(entry.value[:], value)
 entriesCount++
 }
 return &entry.m
 }

 // assume valid input
 for len(data) > 0 {

 idHash := uint64(fnv1aOffset64)
 semiPos := 0
 for i, b := range data {
 if b == ';' {
 semiPos = i
 break
 }

 // calculate FNV-1a hash
 idHash ^= uint64(b)
 idHash *= fnv1aPrime64
 }

 idData := data[:semiPos]

 data = data[semiPos+1:]

 var temp int64
 // parseNumber
 {
 negative := data[0] == '-'
 if negative {
 data = data[1:]
 }

 _ = data[3]
 if data[1] == '.' {
 // 1.2\n
 temp = int64(data[0])*10 + int64(data[2]) - '0'*(10+1)
 data = data[4:]
 // 12.3\n
 } else {
 _ = data[4]
 temp = int64(data[0])*100 + int64(data[1])*10 + int64(data[3]) - '0'*(100+10+1)
 data = data[5:]
 }

 if negative {
 temp = -temp
 }
 }

 m := getMeasurement(idHash, idData)
 if m.count == 0 {
 m.min = temp
 m.max = temp
 m.sum = temp
 m.count = 1
 } else {
 m.min = min(m.min, temp)
 m.max = max(m.max, temp)
 m.sum += temp
 m.count++
 }
 }

 result := make(map[string]*measurement, entriesCount)
 for i := range entries {
 entry := &entries[i]
 if entry.m.count > 0 {
 result[string(entry.value[:entry.vlen])] = &entry.m
 }
 }
 return result
}

func round(x float64) float64 {
 return roundJava(x*10.0) / 10.0
}

// roundJava returns the closest integer to the argument, with ties
// rounding to positive infinity, see java's Math.round
func roundJava(x float64) float64 {
 t := math.Trunc(x)
 if x < 0.0 && t-x == 0.5 {
 //return t
 } else if math.Abs(x-t) >= 0.5 {
 t += math.Copysign(1, x)
 }

 if t == 0 { // check -0
 return 0.0
 }
 return t
}

// parseNumber reads decimal number that matches "^-?[0-9]{1,2}[.][0-9]" pattern,
// e.g.: -12.3, -3.4, 5.6, 78.9 and return the value*10, i.e. -123, -34, 56, 789.
func parseNumber(data []byte) int64 {
 negative := data[0] == '-'
 if negative {
 data = data[1:]
 }

 var result int64
 switch len(data) {
 // 1.2
 case 3:
 result = int64(data[0])*10 + int64(data[2]) - '0'*(10+1)
 // 12.3
 case 4:
 result = int64(data[0])*100 + int64(data[1])*10 + int64(data[3]) - '0'*(100+10+1)
 }

 if negative {
 return -result
 }
 return result
}

https://github.com/aytechnet/1brc

François Pons

package main

import (
 "bytes"
 "flag"
 "fmt"
 "log"
 "os"
 "runtime"
 "runtime/pprof"
 "slices"
 "sync"
 "syscall"
 "sync/atomic"

 "github.com/aytechnet/decimal"
)

type (
 measurement struct {
 hash atomic.Uint64
 minT atomic.Int64
 maxT atomic.Int64
 sumT atomic.Int64
 countT atomic.Int64
 nameLen int
 nameBuf [208]byte
 }

 measurements struct {
 total atomic.Int64
 numParsers int
 results [capacity]measurement
 }

 job struct {
 maxOffset atomic.Int64
 bufLen int
 buf [bufSize]byte
 }
)

const (
 delta = 439
 capacity = 1 << 16 // must be a power of 2 for modulo calculation

 // buffer size
 bufSize = 512 * 1024 // 1Mb

 // use FNV-1a hash
 fnv1aOffset64 = 14695981039346656037
 fnv1aPrime64 = 1099511628211
)

func main() {
 var mode, filename, cpuprofile string
 var res measurements

 flag.StringVar(&mode, "mode", "default", "Which mode to use among 'mmap', 'seq' and 'default'")
 flag.StringVar(&filename, "file", "", "Measurements file to use")
 flag.StringVar(&cpuprofile, "cpuprofile", "", "Write cpuprofile to file")
 flag.IntVar(&res.numParsers, "parsers", runtime.NumCPU(), "Number of thread to use for parsing")

 flag.Parse()

 if filename == "" {
 flag.Usage()
 os.Exit(1)
 }

 if cpuprofile != "" {
 if f, err := os.Create(cpuprofile); err != nil {
 log.Fatal(err)
 } else {
 pprof.StartCPUProfile(f)
 defer pprof.StopCPUProfile()
 }
 }

 f, err := os.Open(filename)
 if err != nil {
 log.Fatalf("Open: %v", err)
 }
 defer f.Close()

 switch mode {
 case "mmap":
 res.processMmap(f)
 case "seq":
 res.processSeq(f)
 default:
 res.process(f)
 }
}

func (res *measurements) processMmap(f *os.File) {
 jobs := make([]job, res.numParsers)

 fi, err := f.Stat()
 if err != nil {
 log.Fatalf("Stat: %v", err)
 }

 size := fi.Size()
 chunkSize := size/int64(len(jobs))
 if chunkSize <= 100 {
 log.Fatalf("Invalid file size: %d", size)
 }

 data, err := syscall.Mmap(int(f.Fd()), 0, int(size), syscall.PROT_READ, syscall.MAP_SHARED)
 if err != nil {
 log.Fatalf("Mmap: %v", err)
 }

 defer func() {
 if err := syscall.Munmap(data); err != nil {
 log.Fatalf("Munmap: %v", err)
 }
 }()

 offset := chunkSize
 for i := range jobs {
 j := &jobs[i]

 if i == len(jobs)-1 {
 j.maxOffset.Store(size)
 } else {
 j.maxOffset.Store(-offset)
 }
 offset += chunkSize
 }

 var wg sync.WaitGroup

 wg.Add(len(jobs))

 offset = 0
 for i := range jobs {
 go func(i int, offset int64){
 defer wg.Done()

 j := &jobs[i]

 maxOffset := j.maxOffset.Load()
 if maxOffset < 0 {
 maxOffset = -maxOffset

 if nlPos := bytes.IndexByte(data[maxOffset:], '\n'); nlPos >= 0 {
 maxOffset += int64(nlPos+1)
 }
 }

 if offset > 0 {
 if nlPos := bytes.IndexByte(data[offset:maxOffset], '\n'); nlPos >= 0 {
 offset += int64(nlPos+1)
 }
 }

 res.processChunk(data[offset:maxOffset])
 }(i, offset)

 offset += chunkSize
 }

 wg.Wait()

 res.printResults()
}

func (res *measurements) processSeq(f *os.File) {
 jobs := make([]job, res.numParsers)
 free_jobs := make(chan *job, len(jobs))
 ready_jobs := make(chan *job, len(jobs))

 var wg sync.WaitGroup

 wg.Add(len(jobs))

 for i := range jobs {
 j := &jobs[i]

 free_jobs <- j
 go func(){
 for j := range ready_jobs {
 res.processChunk(j.buf[:j.bufLen])
 free_jobs <- j
 }
 wg.Done()
 }()
 }

 var prev_j *job

 pos := 0
 nlPos := 0
 for j := range free_jobs {
 if count, _ := f.Read(j.buf[pos:]); count > 0 {
 // finalize previous line from previous job
 if pos > 0 /* && prev_j != nil */ {
 copy(j.buf[:pos], prev_j.buf[bufSize-pos:])
 }

 // prepare next buffer
 if nlPos = bytes.LastIndexByte(j.buf[:pos+count], '\n'); nlPos < 0 {
 log.Fatalf("buffer too small for a complete line");
 } else {
 pos = pos + count - nlPos - 1
 prev_j = j
 j.bufLen = nlPos + 1
 }

 // spawn a new job on this buffer
 ready_jobs <- j
 } else {
 break
 }
 }

 close(ready_jobs)

 wg.Wait()

 close(free_jobs)

 res.printResults()
}

func (res *measurements) process(f *os.File) {
 jobs := make([]job, res.numParsers)

 fi, err := f.Stat()
 if err != nil {
 log.Fatalf("Stat: %v", err)
 }

 size := fi.Size()
 chunkSize := size/int64(len(jobs))
 if chunkSize <= 100 {
 log.Fatalf("Invalid file size: %d", size)
 }

 offset := chunkSize
 for i := range jobs {
 j := &jobs[i]

 if i == len(jobs)-1 {
 j.maxOffset.Store(size)
 } else {
 j.maxOffset.Store(-offset)
 }
 offset += chunkSize
 }

 var wg sync.WaitGroup

 wg.Add(len(jobs))

 offset = 0
 for i := range jobs {
 go func(i int, offset int64){
 defer wg.Done()

 j := &jobs[i]

 nlSkipFirst := offset > 0

 for {
 maxLen := bufSize
 maxOffset := j.maxOffset.Load()
 if maxOffset < 0 {
 maxOffset = -maxOffset
 }
 if offset + int64(maxLen) > maxOffset {
 maxLen = int(maxOffset - offset)
 }

 if count, _ := f.ReadAt(j.buf[:maxLen], offset); count > 0 {
 pos := 0
 if nlSkipFirst {
 if nlPos := bytes.IndexByte(j.buf[:maxLen], '\n'); nlPos >= 0 {
 pos = nlPos + 1
 jobs[i-1].maxOffset.Store(offset + int64(pos))
 nlSkipFirst = false
 } else {
 log.Fatalf("Unable to seek to next line at job n°%d", i)
 }
 }

 if nlPos := bytes.LastIndexByte(j.buf[pos:maxLen], '\n'); nlPos >= 0 {
 j.bufLen = pos + nlPos + 1
 offset += int64(j.bufLen)

 res.processChunk(j.buf[pos:j.bufLen])
 } else {
 log.Fatalf("Buffer too small at job n°%d", i)
 }
 } else {
 return
 }

 maxOffset = j.maxOffset.Load()
 for maxOffset < 0 {
 maxOffset = j.maxOffset.Load()
 }
 if offset >= maxOffset {
 return
 }
 }
 }(i, offset)

 offset += chunkSize
 }

 wg.Wait()

 res.printResults()
}

func (res *measurements) printResults() {
 log.Printf("Read %d entries", res.total.Load())

 ids := make([]int, 0, capacity)

 for i := range res.results {
 m := &res.results[i]

 if m.nameLen > 0 {
 ids = append(ids, i)
 }
 }

 slices.SortFunc(ids, func(a,b int) int {
 return bytes.Compare(res.results[a].nameBuf[0:res.results[a].nameLen], res.results[b].nameBuf[0:res.results[b].nameLen])
 })

 count := 0
 fmt.Print("{")
 for _, i := range ids {
 m := &res.results[i]

 var buf [128]byte // name is 100 chars max, each 3 decimals is 5 bytes max on output
 b := buf[0:0]

 if count > 0 {
 b = append(b, ',', ' ')
 }

 b = append(b, m.nameBuf[0:m.nameLen]...)
 b = append(b, '=')
 b = decimal.New(m.minT.Load(), -1).BytesToFixed(b, 1)
 b = append(b, '/')
 b = decimal.New(m.sumT.Load(), -1).Div(decimal.NewFromInt(m.countT.Load()-1)).BytesToFixed(b, 1)
 b = append(b, '/')
 b = decimal.New(m.maxT.Load(), -1).BytesToFixed(b, 1)
 count++

 fmt.Print(string(b))
 // fmt.Printf("%s=%s/%s/%s", m.nameBuf[0:m.nameLen], decimal.New(m.minT.Load(), -1).StringFixed(1), decimal.New(m.sumT.Load(), -1).Div(decimal.NewFromInt(m.countT.Load()-1)).StringFixed(1), decimal.New(m.maxT.Load(), -1).StringFixed(1))
 count++
 }
 fmt.Println("}")
}

func (res *measurements) processChunk(data []byte) {
 var total int64

 // assume valid input
 for len(data) > 0 {
 i := 0

 // compute FNV-1a hash
 idHash := uint64(fnv1aOffset64)
 for j, b := range data {
 if b == ';' {
 i = j
 break
 }

 // calculate FNV-1a hash
 idHash ^= uint64(b)
 idHash *= fnv1aPrime64
 }
 if idHash == 0 {
 idHash = uint64(len(data))
 }

 idData := data[:i]

 i++ // now i points to temperature

 var temp int64
 // parseNumber
 {
 negative := data[i] == '-'
 if negative {
 i++
 }

 temp = int64(data[i]-'0')
 i++

 if data[i] != '.' {
 temp = temp*10 + int64(data[i]-'0')
 i++
 }
 i++ // data[i] is '.'
 temp = temp*10 + int64(data[i]-'0')
 if negative {
 temp = -temp
 }

 data = data[i+2:]
 }

 // get measurement
 {
 i := idHash & uint64(capacity-1)
 entry := &res.results[i]

 for {
 if entry.hash.CompareAndSwap(0, idHash) {
 // make sure no race occurs as entry may be updated meanwhile as hash has been updated
 if entry.countT.Add(1) == 1 {
 entry.nameLen = len(idData)
 copy(entry.nameBuf[:], idData)
 entry.minT.Store(temp)
 entry.maxT.Store(temp)
 entry.sumT.Store(temp)
 entry.countT.Add(1) // unlock for update below
 } else {
 // wait for countT to be at least 2 for entry init to be complete
 for entry.countT.Load() < 2 {}

 // update existing entry
 minT := entry.minT.Load()
 for minT > temp {
 if entry.minT.CompareAndSwap(minT, temp) {
 break
 } else {
 minT = entry.minT.Load()
 }
 }
 maxT := entry.maxT.Load()
 for maxT < temp {
 if entry.maxT.CompareAndSwap(maxT, temp) {
 break
 } else {
 maxT = entry.maxT.Load()
 }
 }
 entry.sumT.Add(temp)
 entry.countT.Add(1)
 }
 break
 } else if entry.hash.Load() == idHash {
 // the entry is found and may be being updated by another thread
 // wait for countT to be at least 2 for entry init to be complete
 for entry.countT.Load() < 2 {}

 // now that name has been updated, check it is matching
 if len(idData) == entry.nameLen /* bytes.Compare(idData, entry.nameBuf[0:entry.nameLen]) == 0 */ {
 // update existing entry
 minT := entry.minT.Load()
 for minT > temp {
 if entry.minT.CompareAndSwap(minT, temp) {
 break
 } else {
 minT = entry.minT.Load()
 }
 }
 maxT := entry.maxT.Load()
 for maxT < temp {
 if entry.maxT.CompareAndSwap(maxT, temp) {
 break
 } else {
 maxT = entry.maxT.Load()
 }
 }
 entry.sumT.Add(temp)
 entry.countT.Add(1)

 break
 } else {
 // name does not match idData so jump to next entry
 i = (i + delta) & uint64(capacity-1)
 entry = &res.results[i]
 }
 } else {
 i = (i + delta) & uint64(capacity-1)
 entry = &res.results[i]
 }
 }
 }

 total++
 }

 res.total.Add(total)
}

func (entry *measurement) update(temp int64) {
 minT := entry.minT.Load()
 for minT > temp {
 if entry.minT.CompareAndSwap(minT, temp) {
 break
 } else {
 minT = entry.minT.Load()
 }
 }
 maxT := entry.maxT.Load()
 for maxT < temp {
 if entry.maxT.CompareAndSwap(maxT, temp) {
 break
 } else {
 maxT = entry.maxT.Load()
 }
 }
 entry.sumT.Add(temp)
 entry.countT.Add(1)
}

Python's many command-line utilities

Sat, 06 Jul 2024 20:39:01 +0800

Python’s many command-line utilities

These are Python’s most helpful general-purpose command-line tools.

Command	Purpose	More
`python -m http.server`	Start a simple web server	Video
`python -m webbrowser`	Launch your web browser	Docs
`python -m json.tool`	Nicely format JSON data	Docs
`python -m calendar`	Show a command-line calendar	Docs

`http.server`

Running the http.server module as a script will start a web server on port 8000 that hosts files from the current directory. I use this all the time to preview Sphinx documentation sites (especially when using Sphinx’s dirhtml option which is all about subdirectories of index.html files).

Go leetcode

Thu, 20 Jun 2024 18:15:00 +0800

https://books.halfrost.com/leetcode/

Nginx if 避坑指南

Sat, 15 Jun 2024 19:55:10 +0800

if 指令由 rewrite 模块提供，显然它主要是用于 URL 重写领域。典型的 if 用法如下：

http {
 server {
 listen 8080;

 if ($http_user_agent ~ MSIE) {
 rewrite ^(.*)$ /msie/$1 break;
 }

 if ($request_method = POST) {
 return 405;
 }
 }
}

上例中第一个 if 检查如果 user agent 字符串中包含 MSIE，就把 URL 重写为 /msie 开头的路径，这样就可以给微软的 IE 浏览器提供特供版本内容。

第二个 if 检查当前请求的 HTTP 方法，如果是 POST 请求则直接返回 405 状态码。

以上就是 if 最典型的用法，也是 Nginx 最初设想的用法～但很快就被用户玩坏了 😂

天下苦静态配置久矣，Nginx 终于支持动态配置了 👏 这个 if 不就是 c 语言里的条件判断吗？大家玩起来 🎢

Mount AWS S3 Bucket On Amazon EC2

Sun, 09 Jun 2024 15:37:30 +0800

Mount AWS S3 Bucket On Amazon EC2

Use Cases

Data Backup and Archiving: Efficiently store and retrieve data from S3 to perform reliable backups and long-term archiving.
Big Data and Analytics: Directly access large datasets in S3 for seamless data processing and analytics.
Web Hosting and Content Distribution: Serve static content from S3 to host websites and media files efficiently.
Log Collection and Analysis: Centrally store logs in S3 for easy log analysis and monitoring.
File Sharing and Collaboration: Share and collaborate on files among multiple EC2 instances using S3 as a shared data repository.

Prerequisites

WebP Cloud uses Cloudflare Workers to fetch content from the origin server in order to protect the origin server and start providing origin fetch time information.

Sun, 09 Jun 2024 10:49:45 +0800

WebP Cloud uses Cloudflare Workers to fetch content from the origin server in order to protect the origin server and start providing origin fetch time information.

Emoji Regular expression

Sun, 19 May 2024 14:37:00 +0800

Emoji Regular expression

/\p{Emoji}/u

既然是匹配 Emoji，那么 loneProperty (\p{loneProperty}) 就应该是 Emoji ? 实际测试并不符合需求，因为在 Emoji 官方文档中， 123456789*# 也是被看作是 Emoji，如果用这个正则的话，就会把数字也认为是 Emoji，不符合只排除特殊表情的要求。

/\p{Extended_Pictographic}/u

而 Extended_Pictographic 表示的 Emoji 才是我们认为的那些表情符号。

Prometheus relabeling and linux metrics

Tue, 14 May 2024 13:49:00 +0800

Adding new label

- target_label: "foo"
 replacement: "bar"

metrics

rkB/s: rate(node_disk_read_bytes_total[*]) Unit: bytes per second
wkB/s: rate(node_disk_written_bytes_total[*]) Unit: bytes per second

LLMs Hackmd Docs

Fri, 10 May 2024 10:08:00 +0800

LM STUDIO
chromadb/chroma
ollama/ollama
mintplexlabs/anythingllm

More Powerful Go Execution Tracing

Tue, 07 May 2024 11:45:57 +0800

More Powerful Go Execution Tracing

runtime/trace

golang.org/x/exp/trace

Flight Recording

// Set up the flight recorder
fr := trace.NewFlightRecorder()
fr.Start()
// Set up and run the HTTP server
var once sync.Once
http.HandleFunc("/my-endpoint", func(w http.ResponseWriter, r *http.Request) {
 start := time.Now()
 // Do some work
 doWork(w, r)
 // Got a long-running request, take a snapshot
 if time.Since(start) > 300*time.Millisecond {
 // We only do this once for simplicity; you can do it multiple times
 once.Do(func() {
 // Capture snapshot
 var b bytes.Buffer
 _, err = fr.WriteTo(&b)
 if err != nil {
 log.Print(err)
 return
 }
 // Write snapshot to file
 if err := os.WriteFile("trace.out", b.Bytes(), 0o755); err != nil {
 log.Print(err)
 return
 }
 })
 }
})
log.Fatal(http.ListenAndServe(":8080", nil))

Trace Reader API

// Start reading trace data from stdin.
r, err := trace.NewReader(os.Stdin)
if err != nil {
 log.Fatal(err)
}
var blocked int
var blockedOnNetwork int
for {
 // Read event
 ev, err := r.ReadEvent()
 if err == io.EOF {
 break
 } else if err != nil {
 log.Fatal(err)
 }
 // Handle it
 if ev.Kind() == trace.EventStateTransition {
 st := ev.StateTransition()
 if st.Resource.Kind == trace.ResourceGoroutine {
 id := st.Resource.Goroutine()
 from, to := st.GoroutineTransition()
 // Find blocked goroutines and count them
 if from.Executing() && to == trace.GoWaiting {
 blocked++
 if strings.Contains(st.Reason, "network") {
 blockedOnNetwork++
 }
 }
 }
 }
}

// Print the values we need
p := 100 * float64(blockedOnNetwork) / float64(blocked)
fmt.Printf("%2.3f%% instances of goroutines blocking were to block on the network\n", p)

Taide - training data

Sat, 27 Apr 2024 17:10:00 +0800

Taide - training data

Run llama3

Thu, 25 Apr 2024 10:14:00 +0800

Docker-compose

version: "3.8"

services:
 ollama:
 image: ollama/ollama:latest
 container_name: ollama
 restart: unless-stopped
 volumes:
 - ./ollama/ollama:/root/.ollama
 tty: true
 ports:
 - 11434:11434
 networks:
 - ollama-docker
 # deploy:
 # resources:
 # reservations:
 # devices:
 # - driver: nvidia
 # count: 1
 # capabilities: [gpu]
 ollama-webui:
 image: ghcr.io/ollama-webui/ollama-webui:main
 container_name: ollama-webui
 restart: unless-stopped
 volumes:
 - ./ollama/ollama-webui:/app/backend/data
 ports:
 - 8080:8080
 environment:
 - "/ollama/api=http://ollama:11434/api"
 extra_hosts:
 - host.docker.internal:host-gateway
 networks:
 - ollama-docker

networks:
 ollama-docker:

Setup

# Run docker-compose
docker-compose up -d

# Pull model(https://ollama.com/library)
docker exec -it ollama /bin/bash
ollama pull llama3

Chat with Web-UI

port defined in docker-compose.yml ollama-webui.ports

Go 1.21 GA PGO Optimization You Can't Grasp in One Read — A Try on WebP Server Go

Thu, 25 Apr 2024 09:22:00 +0800

Go 1.21 GA PGO Optimization You Can’t Grasp in One Read — A Try on WebP Server Go

Go Style Decisions - Pass values

Sat, 13 Apr 2024 17:38:00 +0800

Go Style Decisions - Pass values

Do not pass pointers as function arguments just to save a few bytes. If a function reads its argument x only as *x throughout, then the argument shouldn’t be a pointer. Common instances of this include passing a pointer to a string (*string) or a pointer to an interface value (*io.Reader). In both cases, the value itself is a fixed size and can be passed directly.

Go Generics Beginner Notes

Wed, 07 Feb 2024 19:52:22 +0800

Go Generics Beginner Notes

Custom Constraints

// Addable allows only int or float64 types
type Addable interface {
 int | float64
}

func Add[T Addable](a, b T) T {
 return a + b
}

What ~ Means ~ represents all types that share the same underlying type as the specified type. When you use ~ in a type parameter constraint, you define a type set that includes all types whose underlying type matches the specified type.

type MyInt int
type YourInt int

func PrintInt[T ~int](t T) {
 fmt.Println(t)
}

func main() {
 var a int = 5
 var b MyInt = 10
 var c YourInt = 15

 PrintInt(a)
 PrintInt(b)
 PrintInt(c)
}

Tracking SQLite Database Changes in Git

Wed, 07 Feb 2024 19:20:15 +0800

First, add a diff type called “sqlite3” to your config. The simplest way is to just run these commands:

git config diff.sqlite3.binary true git config diff.sqlite3.textconv "echo .dump | sqlite3"

Alternatively, you can add this snippet to your ~/.gitconfig or .git/config in your repository:

[diff "sqlite3"] binary = true textconv = "echo .dump | sqlite3"

Next, create a file called .gitattributes if it’s not already present and add this line:

LLM Visualization

Sun, 21 Jan 2024 12:40:00 +0800

Tuning EMQX to Scale to One Million Concurrent Connection on Kubernetes

Sun, 21 Jan 2024 12:34:35 +0800

Tuning EMQX to Scale to One Million Concurrent Connection on Kubernetes

llamafile - Distribute and run LLMs with a single file.

Sun, 21 Jan 2024 09:30:54 +0800

Database Fundamentals

Mon, 01 Jan 2024 18:46:17 +0800

Database Fundamentals