Hero Image
Go leetcode

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

Thursday, June 20, 2024 Read
Hero Image
More Powerful Go Execution Tracing

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)

Tuesday, May 7, 2024 Read
Hero Image
Run llama3

ollama/ollama Ollama ＋ Open WebUI，快捷部署 AI 大型語言模型到你的電腦，離線執行 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

Thursday, April 25, 2024 Read
Hero Image
Go 1.21 GA PGO Optimization You Can't Grasp in One Read — A Try on WebP Server Go

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

Thursday, April 25, 2024 Read
Hero Image
Go Style Decisions - Pass values

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.

Saturday, April 13, 2024 Read
Hero Image
Go Generics Beginner Notes

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) }

Wednesday, February 7, 2024 Read
Hero Image
Golang Tips

Go Programming Patterns: Slices, Interfaces, Time, and Performance Go is a high-performance language, but that does not mean we can ignore performance. Here are some tips related to programming and performance. If you need to convert numbers to strings, strconv.Itoa() is about twice as fast as fmt.Sprintf(). Avoid converting String to []Byte where possible. This conversion hurts performance. If you use append() on a slice inside a for-loop, expand the slice capacity ahead of time to avoid reallocations and automatic growth by powers of two, which can waste memory. Use StringBuffer or StringBuild to concatenate strings; they are three to four orders of magnitude faster than + or +=. Use concurrent goroutines where possible, and use sync.WaitGroup to synchronize concurrent work. Avoid allocating in hot paths; it makes the GC busy. Use sync.Pool to reuse objects. Use lock-free operations and avoid mutexes when possible; use sync/Atomic. (See Lock-Free Queue Implementation or Lock-Free Hashmap Implementation.) Use I/O buffering; I/O is very slow. bufio.NewWrite() and bufio.NewReader() improve performance. For fixed regex patterns in a for-loop, use regexp.Compile() to precompile; it improves performance by two orders of magnitude. If you need higher-performance protocols, consider protobuf or msgp instead of JSON, because JSON serialization/deserialization uses reflection. When using maps, integer keys are faster than string keys because integer comparisons are faster.

Tuesday, September 26, 2023 Read
Hero Image
Go Patterns

Go Patterns go-design-pattern

Saturday, September 16, 2023 Read
Hero Image
15 Rules of Channels and Their Implementation

15 Rules of Channels and Their Implementation Operation rules Operation nil Closed channel Open buffered channel Open unbuffered channel Close panic panic Close succeeds; buffered values can be read. After buffer drains, further reads return the zero value of the channel type. Close succeeds; further reads return the zero value of the channel type. Receive Block Non-blocking; returns the zero value of the channel type Non-blocking; reads values normally Block Send Block panic Non-blocking; writes values normally Block Compile-time rules Operation Channel type Result Receive Send-only channel Compile error Send Receive-only channel Compile error Close Receive-only channel Compile error

Thursday, June 22, 2023 Read
Hero Image
Pitfalls When Parsing Binary Data in Go

Pitfalls When Parsing Binary Data in Go for { buf := make([]byte, bufSize) n, err := r.Read(buf) if err == io.EOF { return } else if err != nil { aerr.Store(err) return } ch <- buf[:n] } The code returns immediately when err is io.EOF, which is the most likely problem. The docs say: Callers should always process the n > 0 bytes returned before considering the error err. Doing so correctly handles I/O errors that happen after reading some bytes and also both of the allowed EOF behaviors.

Friday, January 20, 2023 Read
Hero Image
Take Screenshots with Selenium in Go

Take Screenshots with Selenium in Go package main import ( "fmt" log "github.com/sirupsen/logrus" "github.com/tebeka/selenium" "io/ioutil" ) const ( chromeDriverPath = "/usr/local/bin/chromedriver" port = 9515 ) func main() { var opts []selenium.ServiceOption selenium.SetDebug(false) service, err := selenium.NewChromeDriverService(chromeDriverPath, port, opts...) if err != nil { panic(err) // panic is used only as an example and is not otherwise recommended. } defer service.Stop() caps := selenium.Capabilities{"browserName": "chrome"} // Full-page screenshot // Get page width/height, resize the browser window, then take a screenshot. // Note: only headless mode allows arbitrary window sizes; otherwise the max height cannot exceed your screen resolution. // chromeCaps := chrome.Capabilities{ // Path: "", // Args: []string{ // "--headless", // }, // } // caps.AddChrome(chromeCaps) wd, err := selenium.NewRemote(caps, fmt.Sprintf("http://localhost:%d/wd/hub", port)) if err != nil { panic(err) } defer wd.Quit() // ExecuteScript can run JavaScript. The return value is interface{}, so assert to float then convert to int. // height, _ := wd.ExecuteScript("return document.body.parentNode.scrollHeight", nil) // var realHeight = int(height.(float64)) // Then set the window size. // wd.ResizeWindow("", 1920, realHeight) if err := wd.Get("https://github.com/tgbot-collection/archiver"); err != nil { panic(err) } screenshot, err := wd.Screenshot() if err != nil { log.Errorln(err) } ioutil.WriteFile("screenshot.png", screenshot, 0644) } Full-page screenshot Get the page width/height, resize the browser window accordingly, and then take the screenshot. Note that only headless mode allows arbitrary window sizes; otherwise the maximum height cannot exceed your display resolution.

Friday, December 2, 2022 Read
Hero Image
Use Go Fuzzing to Write More Complete Unit Tests

Use Go Fuzzing to Write More Complete Unit Tests func Pow(base uint, exponent uint) uint { if exponent == 0 { return 1 } return base * Pow(base, exponent-1) } func FuzzPow(f *testing.F) { f.Fuzz(func(t *testing.T, x, y uint) { assert := assert.New(t) assert.Equal(Pow(x, 0), uint(1)) assert.Equal(Pow(x, 1), x) assert.Equal(Pow(x, 2), x*x) if x > 0 && y > 0 { assert.Equal(Pow(x, y)/x, Pow(x, y-1)) } }) } go test -fuzz=Fuzz -fuzztime 20s When a fuzz test fails, Go records the input in testcase/ You will find that when x=6 and y=30, the assert fails, i.e., pow(6, 30)/6 is not equal to pow(6, 29). That seems odd, but after testing you will see it is because pow(6, 30) overflows. The max.MaxUint in Go is about 18 * 10^¹⁸, while 6^²⁹ is about 7 * 10^¹⁸. If you multiply 6^²⁹ by 6, it overflows and yields 8 * 10^¹⁸. It is like running two laps and ending up near the starting point. var ErrOverflow = fmt.Errorf("overflow") func Pow(base uint, exponent uint) (uint, error) { if exponent == 0 { return 1 } prevResult, err := Pow(base, exponent-1) if math.MaxUint/base < prevResult { return 0, ErrOverflow } return base * prevResult, nil } func FuzzPow(f *testing.F) { f.Fuzz(func(t *testing.T, x, y uint) { assert := assert.New(t) if result, err := Pow(x, 1); err != ErrOverflow { assert.Equal(result, x) } if result, err := Pow(x, y); x > 0 && y > 0 && err != ErrOverflow { resultDivX, _ := Pow(x, y-1) assert.Equal(result/x, resultDivX) } }) }

Thursday, November 3, 2022 Read