init module

Author: sisyphsu

.travis.yml

@@ -0,0 +1,11 @@
+language: go
+go:
+  - "1.13.x"
+  - "1.14.x"
+  - "1.15.x"
+  - "1.16.x"
+
+script:
+  - export GOMAXPROCS=4
+  - export GORACE=halt_on_error=1
+  - go test -race -v ./...

README.md

@@ -1 +1,17 @@
-# routine
+# routine
+
+# API
+
+## `Goid()`
+
+`Goid()` helps you get the unique `goid` of the current `goroutine` easily.
+
+## `AllGoids()`
+
+`AllGoids()` helps you find all `goid` of alive `goroutine`s easily.
+
+## `LocalStorage`
+
+# License
+
+MIT

g/g.go

@@ -0,0 +1,16 @@
+// Copyright 2018 Huan Du. All rights reserved.
+// Licensed under the MIT license that can be found in the LICENSE file.
+
+// Package g exposes goroutine struct g to user space.
+package g
+
+import (
+	"unsafe"
+)
+
+func getg() unsafe.Pointer
+
+// G returns current g (the goroutine struct) to user space.
+func G() unsafe.Pointer {
+	return getg()
+}

g/g_test.go

@@ -0,0 +1,28 @@
+// Copyright 2018 Huan Du. All rights reserved.
+// Licensed under the MIT license that can be found in the LICENSE file.
+
+package g
+
+import (
+	"testing"
+)
+
+func TestG(t *testing.T) {
+	gp1 := G()
+
+	if gp1 == nil {
+		t.Fatalf("fail to get G.")
+	}
+
+	t.Run("G in another goroutine", func(t *testing.T) {
+		gp2 := G()
+
+		if gp2 == nil {
+			t.Fatalf("fail to get G.")
+		}
+
+		if gp2 == gp1 {
+			t.Fatalf("every living G must be different. [gp1:%p] [gp2:%p]", gp1, gp2)
+		}
+	})
+}

g/getg_386.s

@@ -0,0 +1,12 @@
+// Copyright 2018 Huan Du. All rights reserved.
+// Licensed under the MIT license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+TEXT ·getg(SB), NOSPLIT, $0-4
+    get_tls(CX)
+    MOVL    g(CX), AX
+    MOVL    AX, ret+0(FP)
+    RET

g/getg_amd64.s

@@ -0,0 +1,12 @@
+// Copyright 2018 Huan Du. All rights reserved.
+// Licensed under the MIT license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+TEXT ·getg(SB), NOSPLIT, $0-8
+    get_tls(CX)
+    MOVQ    g(CX), AX
+    MOVQ    AX, ret+0(FP)
+    RET

g/getg_amd64p32.s

@@ -0,0 +1,4 @@
+// Copyright 2018 Huan Du. All rights reserved.
+// Licensed under the MIT license that can be found in the LICENSE file.
+
+#include "getg_amd64.s"

g/getg_arm.s

@@ -0,0 +1,10 @@
+// Copyright 2018 Huan Du. All rights reserved.
+// Licensed under the MIT license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·getg(SB), NOSPLIT, $0-4
+    MOVW    g, R8
+    MOVW    R8, ret+0(FP)
+    RET

g/getg_arm64.s

@@ -0,0 +1,10 @@
+// Copyright 2018 Huan Du. All rights reserved.
+// Licensed under the MIT license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·getg(SB), NOSPLIT, $0-4
+    MOVW    g, R8
+    MOVW    R8, ret+0(FP)
+    RET

g/go_tls.h

@@ -0,0 +1,22 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifdef GOARCH_arm
+#define LR R14
+#endif
+
+#ifdef GOARCH_amd64
+#define	get_tls(r)	MOVQ TLS, r
+#define	g(r)	0(r)(TLS*1)
+#endif
+
+#ifdef GOARCH_amd64p32
+#define	get_tls(r)	MOVL TLS, r
+#define	g(r)	0(r)(TLS*1)
+#endif
+
+#ifdef GOARCH_386
+#define	get_tls(r)	MOVL TLS, r
+#define	g(r)	0(r)(TLS*1)
+#endif

go.mod

@@ -0,0 +1,5 @@
+module github.com/go-eden/routine
+
+go 1.16
+
+require github.com/stretchr/testify v1.7.0

routine.s

@@ -0,0 +1,86 @@
+package routine
+
+import "fmt"
+
+// LocalStorage provides goroutine-local variables.
+type LocalStorage interface {
+
+	// Get returns the value in the current goroutine's local storage, if it was set before.
+	Get() (value interface{})
+
+	// Set copy the value into the current goroutine's local storage, and return the old value.
+	Set(value interface{}) (oldValue interface{})
+
+	// Del delete the value from the current goroutine's local storage, and return it.
+	Del() (oldValue interface{})
+
+	// Clear delete values from all goroutine's local storages.
+	Clear()
+}
+
+// ImmutableContext represents all local storages of one goroutine.
+type ImmutableContext struct {
+	gid    int64
+	values map[uintptr]interface{}
+}
+
+// Go start an new goroutine, and copy all local storages from current goroutine.
+func Go(f func()) {
+	ic := BackupContext()
+	go func() {
+		InheritContext(ic)
+		f()
+	}()
+}
+
+// BackupContext copy all local storages into an ImmutableContext instance.
+func BackupContext() *ImmutableContext {
+	s := loadCurrentStore()
+	data := make(map[uintptr]interface{}, len(s.values))
+	for k, v := range s.values {
+		data[k] = v
+	}
+	return &ImmutableContext{gid: s.gid, values: data}
+}
+
+// InheritContext load the specified ImmutableContext instance into the local storage of current goroutine.
+func InheritContext(ic *ImmutableContext) {
+	if ic == nil || ic.values == nil {
+		return
+	}
+	s := loadCurrentStore()
+	for k, v := range ic.values {
+		s.values[k] = v
+	}
+}
+
+// NewLocalStorage create and return an new LocalStorage instance.
+func NewLocalStorage() LocalStorage {
+	t := new(storage)
+	t.Clear()
+	return t
+}
+
+// Goid return the current goroutine's unique id.
+// It will try get gid by native cgo/asm for better performance,
+// and could parse gid from stack for failover supporting.
+func Goid() (id int64) {
+	var succ bool
+	if id, succ = getGoidByNative(); !succ {
+		// no need to warning
+		id = getGoidByStack()
+	}
+	return
+}
+
+// AllGoids return all goroutine's goid in the current golang process.
+// It will try load all goid from runtime natively for better performance,
+// and fallover to runtime.Stack, which is realy inefficient.
+func AllGoids() (ids []int64) {
+	var err error
+	if ids, err = getAllGoidByNative(); err != nil {
+		fmt.Println("[WARNING] cannot get all goid from runtime natively, now fallover to stack info, this will be very inefficient!!!")
+		ids = getAllGoidByStack()
+	}
+	return
+}

routine_api.go

@@ -0,0 +1,61 @@
+package routine
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"time"
+)
+
+func TestGoid(t *testing.T) {
+	t.Log(Goid())
+}
+
+func TestAllGoid(t *testing.T) {
+	const num = 10
+	for i := 0; i < num; i++ {
+		go func() {
+			time.Sleep(time.Second)
+		}()
+	}
+	time.Sleep(time.Millisecond)
+
+	ids := AllGoids()
+	t.Log("all gids: ", len(ids), ids)
+}
+
+func TestGoStorage(t *testing.T) {
+	var variable = "hello world"
+	stg := NewLocalStorage()
+	stg.Set(variable)
+	Go(func() {
+		v := stg.Get()
+		assert.True(t, v != nil && v.(string) == variable)
+	})
+	time.Sleep(time.Millisecond)
+	stg.Clear()
+}
+
+// BenchmarkGoid-12    	278801190	         4.586 ns/op	       0 B/op	       0 allocs/op
+func BenchmarkGoid(b *testing.B) {
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = Goid()
+	}
+}
+
+// BenchmarkAllGoid-12    	 5949680	       228.3 ns/op	     896 B/op	       1 allocs/op
+func BenchmarkAllGoid(b *testing.B) {
+	const num = 16
+	for i := 0; i < num; i++ {
+		go func() {
+			time.Sleep(time.Second)
+		}()
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = AllGoids()
+	}
+}