forked from GoBelieveIO/im_service
/
benchmark_storage.go
123 lines (99 loc) · 2.46 KB
/
benchmark_storage.go
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
package main
import "log"
import "flag"
import "runtime"
import "time"
import "fmt"
var storage_address string = "127.0.0.1:3333"
var appid int64 = 8
var device_id int64 = 1
var concurrent int
var count int
var c chan bool
func init() {
flag.IntVar(&concurrent, "c", 10, "concurrent number")
flag.IntVar(&count, "n", 100000, "request number")
}
func Test_SetAndEnqueue() {
storage := NewStorageConn()
err := storage.Dial(storage_address)
if err != nil {
log.Println("connect storage err:", err)
return
}
defer storage.Close()
im := &IMMessage{sender:1, receiver:1000, content:"1111"}
m := &Message{cmd:MSG_IM, body:im}
sae := &SAEMessage{}
sae.msg = m
sae.appid = appid
sae.receiver = 1000
sae.device_id = device_id
msgid, err := storage.SaveAndEnqueueMessage(sae)
if err != nil {
log.Println("saveandequeue message err:", err)
return
}
log.Println("msgid:", msgid)
messages, err := storage.LoadOfflineMessage(appid, 1000, device_id)
if err != nil {
log.Println("load offline message err:", err)
return
}
for _, emsg := range(messages) {
im := emsg.msg.body.(*IMMessage)
log.Printf("message id:%d sender:%d receiver:%d content:%s\n",
emsg.msgid, im.sender, im.receiver, string(im.content))
}
dq := &DQMessage{msgid:msgid, appid:appid, receiver:1000}
err = storage.DequeueMessage(dq)
if err != nil {
log.Println("dequeue err:", err)
} else {
log.Printf("dequeue msgid:%d success\n", msgid)
}
}
func benchmark() {
storage := NewStorageConn()
err := storage.Dial(storage_address)
if err != nil {
log.Println("connect storage err:", err)
return
}
defer storage.Close()
for i := 0; i < count; i++ {
im := &IMMessage{sender:1, receiver:1000, content:"1111"}
m := &Message{cmd:MSG_IM, body:im}
sae := &SAEMessage{}
sae.msg = m
sae.appid = appid
sae.receiver = 1000
_, err := storage.SaveAndEnqueueMessage(sae)
if err != nil {
log.Println("saveandequeue message err:", err)
return
}
//log.Println("msgid:", msgid)
}
c <- true
}
func main() {
runtime.GOMAXPROCS(4)
flag.Parse()
fmt.Printf("concurrent:%d, request:%d\n", concurrent, count)
log.SetFlags(log.Lshortfile | log.LstdFlags)
c = make(chan bool, 100)
begin := time.Now().UnixNano()
for i := 0; i < concurrent; i++ {
go benchmark()
}
for i := 0; i < concurrent; i++ {
<- c
}
end := time.Now().UnixNano()
var tps int64 = 0
if end-begin > 0 {
tps = int64(1000*1000*1000*concurrent*count) / (end - begin)
}
fmt.Println("tps:", tps)
}