deep-learning-speech-model-diagram

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package contexthelper

import (
	"context"
)

type k int

var contextKey = k(0)

// Store returns a copy of parent in which the value associated with key is value
func Store(ctx context.Context, key string, value interface{}) context.Context {
	var m map[string][]interface{}
	i := ctx.Value(contextKey)
	if i == nil {
		m = map[string][]interface{}{}
		ctx = context.WithValue(ctx, contextKey, m)
	} else {
		m = i.(map[string][]interface{})
	}

	m[key] = append(m[key], value)
	return ctx
}

// StoreSingleValue returns a copy of parent in which the value associated with key is value
func StoreSingleValue(ctx context.Context, key string, value interface{}) context.Context {
	var m map[string][]interface{}
	i := ctx.Value(contextKey)
	if i == nil {
		m = map[string][]interface{}{}
		ctx = context.WithValue(ctx, contextKey, m)
	} else {
		m = i.(map[string][]interface{})
	}

	m[key] = []interface{}{value}
	return ctx
}

// Load returns the first value associated with this context for key
func Load(ctx context.Context, key string) interface{} {
	values := LoadAll(ctx, key)
	if len(values) < 1 {
		return nil
	}

	return values[0]
}

// LoadAll returns all value associated with this context for key
func LoadAll(ctx context.Context, key string) []interface{} {
	i := ctx.Value(contextKey)
	if i == nil {
		return nil
	}

	return i.(map[string][]interface{})[key]
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

package v2

import (
	"context"
	"sync"
)

type k int

var contextKey = k(0)

type valuesMap struct {
	store     map[string][]interface{}
	parentCtx context.Context
	lock      sync.RWMutex
}

func newValuesMap(parentCtx context.Context) *valuesMap {
	return &valuesMap{
		store:     make(map[string][]interface{}),
		parentCtx: parentCtx,
	}
}

// Store returns a copy of parent in which the value associated with key is value
func Store[T any](ctx context.Context, key string, values ...T) context.Context {
	vm, ok := ctx.Value(contextKey).(*valuesMap)
	if !ok {
		vm = newValuesMap(ctx)
		ctx = context.WithValue(ctx, contextKey, vm)
	}

	vm.lock.Lock()
	defer vm.lock.Unlock()
	for _, value := range values {
		vm.store[key] = append(vm.store[key], value)
	}

	return ctx
}

// StoreSingleValue returns a copy of parent in which the value associated with key is value
func StoreSingleValue[T any](ctx context.Context, key string, value T) context.Context {
	vm, ok := ctx.Value(contextKey).(*valuesMap)
	if !ok {
		vm = newValuesMap(ctx)
		ctx = context.WithValue(ctx, contextKey, vm)
	}

	vm.lock.Lock()
	defer vm.lock.Unlock()
	vm.store[key] = []interface{}{value}

	return ctx
}

// Load returns the first value stored in the context for the given key.
func Load[T any](ctx context.Context, key string) (value T) {
	values := LoadAll[T](ctx, key)
	if len(values) > 0 {
		return values[0]
	}
	return
}

// LoadAll returns all value associated with this context for key
func LoadAll[T any](ctx context.Context, key string) []T {
	vm, ok := ctx.Value(contextKey).(*valuesMap)
	if !ok {
		return nil
	}

	vm.lock.RLock()
	defer vm.lock.RUnlock()
	values, ok := vm.store[key]
	if !ok {
		return nil
	}

	var result []T
	for _, v := range values {
		value, ok := v.(T)
		if ok {
			result = append(result, value)
		}
	}
	return result
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

package v2_test

import (
	"context"
	"fmt"
	"os"
	"sync"
	"testing"

	uuid "github.com/satori/go.uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/suite"
	v2 "gl.fotechwealth.com.local/backend/trade-lib.git/contexthelper/v2"
)

type TestSuite struct {
	suite.Suite
}

func (s *TestSuite) TestRun() {
	ctx := context.WithValue(context.TODO(), "parent", "1")
	requestId := uuid.NewV4().String()
	requestContext := "POST:/ping"
	uin := "1"
	pid := os.Getpid()

	ctx = v2.Store(ctx, "requestId", requestId)
	ctx = v2.Store(ctx, "requestContext", requestContext)
	ctx = v2.Store(ctx, "uin", uin)
	ctx = v2.Store(ctx, "pid", pid)

	// 使用标准 context 库完全不受影响
	ctx = context.WithValue(ctx, "son", "2")

	s.Equal(requestId, v2.Load[string](ctx, "requestId"))
	s.Equal(requestContext, v2.Load[string](ctx, "requestContext"))
	s.Equal(uin, v2.Load[string](ctx, "uin"))
	s.Equal(pid, v2.Load[int](ctx, "pid"))
	s.Equal("1", ctx.Value("parent"))
	s.Equal("2", ctx.Value("son"))

	// 存入多个值映射到相同 key
	ctx = v2.Store(ctx, "uin", "2")
	ctx = v2.Store(ctx, "uin", "3")

	s.Equal([]string{"1", "2", "3"}, v2.LoadAll[string](ctx, "uin"))
}

func TestAll(t *testing.T) {
	suite.Run(t, &TestSuite{})
}

func TestStoreMultipleValues(t *testing.T) {
	ctx := context.Background()
	requestId := uuid.NewV4().String()

	// 存储多个值到相同的键
	ctx = v2.Store(ctx, "requestId", requestId, "anotherId", "yetAnotherId")

	// 从context中加载所有的值
	values := v2.LoadAll[string](ctx, "requestId")
	assert.Equal(t, 3, len(values))
	assert.Equal(t, requestId, values[0])
	assert.Equal(t, "anotherId", values[1])
	assert.Equal(t, "yetAnotherId", values[2])
}

func TestStoreSingleValue(t *testing.T) {
	t.Run("", func(t *testing.T) {
		ctx := context.Background()
		requestId := uuid.NewV4().String()
		ctx = v2.StoreSingleValue(ctx, "requestId", requestId)
		t.Logf("ctx value:%+v", v2.Load[string](ctx, "requestId"))

		newRequestId := uuid.NewV4().String()
		ctx = v2.StoreSingleValue(ctx, "requestId", newRequestId)
		t.Logf("ctx value:%+v", v2.Load[string](ctx, "requestId"))
	})
}

func TestWriteDoesNotAffectParentContext(t *testing.T) {
	parentCtx := context.Background()
	childCtx := v2.Store(parentCtx, "childKey", "childValue")

	// 子context应有新值
	childValue := v2.Load[string](childCtx, "childKey")
	assert.Equal(t, "childValue", childValue)

	// 父context不应有子context的值
	parentValue := v2.Load[string](parentCtx, "childKey")
	assert.Equal(t, "", parentValue)
}

func TestCascadingReadFromParentContext(t *testing.T) {
	parentCtx := context.Background()
	parentCtx = v2.Store(parentCtx, "parentKey", "parentValue")
	childCtx := v2.Store(parentCtx, "childKey", "childValue")

	// 子context应有新值
	childValue := v2.Load[string](childCtx, "childKey")
	assert.Equal(t, "childValue", childValue)

	// 子context应级联读取父context的值
	parentValue := v2.Load[string](childCtx, "parentKey")
	assert.Equal(t, "parentValue", parentValue)
}

// 测试并发功能
func TestConcurrentReadWrite(t *testing.T) {
	ctx := context.Background()

	// 创建一个临时上下文，以便在写入完成后切换回
	tmpCtx := context.Background()

	// 并发写入
	var wg sync.WaitGroup
	for i := 0; i < 10000; i++ {
		uniqueKey := fmt.Sprintf("concurrentKey_%d", i)

		wg.Add(1)
		go func(i int, key string) {
			defer wg.Done()
			tmpCtx = v2.Store(tmpCtx, key, i)
		}(i, uniqueKey)
	}

	// 确保所有写入操作完成
	wg.Wait()

	// 将写入完成后的临时上下文赋值给原始上下文
	ctx = tmpCtx

	// 并发读取
	wg = sync.WaitGroup{}
	for i := 0; i < 10000; i++ {
		uniqueKey := fmt.Sprintf("concurrentKey_%d", i)

		wg.Add(1)
		go func(i int, key string) {
			defer wg.Done()
			value := v2.Load[int](ctx, key)
			if value != i {
				t.Errorf("键 %s 的值应该是 %d，但得到的是 %v", key, i, value)
			}
		}(i, uniqueKey)
	}

	// 等待所有读取完成
	wg.Wait()

	// 如果没有出现任何 Error 或 Fatal，那么测试就是成功的
	t.Log("TestConcurrentReadWrite passed")
}

// TestConcurrentReadWhileWrite 边读边写，没有报错就是成功
func TestConcurrentReadWhileWrite(t *testing.T) {
	originalCtx := context.Background()
	var ctx context.Context
	var wg sync.WaitGroup
	key := "concurrentKey"

	// 定义写入函数
	writeFunc := func(value string) {
		ctx = v2.Store(originalCtx, key, value)
	}

	// 定义读取函数
	readFunc := func() string {
		return v2.Load[string](ctx, key)
	}

	// 启动多个写入 goroutines
	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			value := fmt.Sprintf("value%d", i)
			writeFunc(value)
		}(i)
	}

	// 启动多个读取 goroutines
	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			readValue := readFunc()
			t.Log("Read value:", readValue)
			// 这里不使用断言，因为读取到的值可能会在写入时改变
		}()
	}

	// 等待所有 goroutines 完成
	wg.Wait()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package v2_test

import (
	"context"
	"testing"

	old "path_to_old_version/contexthelper"
	new "path_to_new_version/contexthelper/v2"
	"github.com/stretchr/testify/assert"
)

func TestCompatibility(t *testing.T) {
	ctx := context.Background()

	// 使用旧版本存储值
	ctx = old.Store(ctx, "testKey", "testValue")

	// 尝试使用新版本读取值
	retrievedValue := new.Load[string](ctx, "testKey")
	assert.Equal(t, "testValue", retrievedValue, "The value retrieved by new version should match the value stored by old version.")
}

1
2
3
4
5
6
7
8
9
10

func TestCompatibility(t *testing.T) {
	ctx := context.Background()

	// 使用旧版本存储值
	ctx = contexthelper.Store(ctx, "testKey", "testValue")

	// 尝试使用新版本读取值
	retrievedValue := v2.Load[string](ctx, "testKey")
	assert.Equal(t, "testValue", retrievedValue, "The value retrieved by new version should match the value stored by old version.")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

func Load[T any](ctx context.Context, key string) (value T) {
	vm, ok := ctx.Value(contextKey).(*valuesMap)
	if !ok {
		// 尝试使用旧版本的数据结构
		oldMap, ok := ctx.Value(contextKey).(map[string][]interface{})
		if ok && len(oldMap[key]) > 0 {
			firstVal, ok := oldMap[key][0].(T)
			if ok {
				return firstVal
			}
		}
		return
	}

	return LoadAll[T](ctx, key)[0]
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// LoadAll returns all value associated with this context for key
func LoadAll[T any](ctx context.Context, key string) []T {
    vm, ok := ctx.Value(contextKey).(*valuesMap)
    if !ok {
        // 处理旧版本的存储结构
        oldMap, ok := ctx.Value(contextKey).(map[string][]interface{})
        if ok {
            if oldValues, found := oldMap[key]; found {
                var result []T
                for _, v := range oldValues {
                    if value, ok := v.(T); ok {
                        result = append(result, value)
                    }
                }
                return result
            }
            return nil
        }
        return nil
    }

    vm.lock.RLock()
    defer vm.lock.RUnlock()
    values, ok := vm.store[key]
    if !ok {
        return nil
    }

    var result []T
    for _, v := range values {
        if value, ok := v.(T); ok {
            result = append(result, value)
        }
    }
    return result
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package contexthelper

import (
	"context"
	"fmt"
)

// SimpleStore 存储一个值到上下文，并返回更新的上下文
func SimpleStore(ctx context.Context, key string, value interface{}) context.Context {
	ctx = context.WithValue(ctx, contextKey, map[string]interface{}{
		key: value,
	})
	fmt.Printf("Stored key: %s with value: %v\n", key, value)
	return ctx
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// SimpleLoad 从上下文读取一个值
func SimpleLoad(ctx context.Context, key string) interface{} {
	values, ok := ctx.Value(contextKey).(map[string]interface{})
	if !ok {
		fmt.Println("No value found for key:", key)
		return nil
	}
	value, found := values[key]
	if !found {
		fmt.Println("No value found for key:", key)
		return nil
	}
	fmt.Printf("Retrieved key: %s with value: %v\n", key, value)
	return value
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

package contexthelper_test

import (
	"context"
	"testing"

	"path_to_your_package/contexthelper"
)

func TestSimpleStoreLoad(t *testing.T) {
	ctx := context.Background()

	// 使用 SimpleStore 存储值
	ctx = contexthelper.SimpleStore(ctx, "testKey", "testValue")

	// 使用 SimpleLoad 读取值
	value := contexthelper.SimpleLoad(ctx, "testKey")
	if value != "testValue" {
		t.Errorf("Expected 'testValue', got '%v'", value)
	}
}