reid from https://github.com/michuanhaohao/reid-strong-baseline
zhangmeng
2020-01-17 5cf6c1ccbd4bae01920a2dffcd26f95090d43b63
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
package rpc
 
import (
    "context"
 
    "time"
 
    "basic.com/valib/deliver.git"
)
 
const mode = deliver.PushPull
 
// Reciever recv from ipc
type Reciever struct {
    ctx    context.Context
    ipcURL string
    out    chan<- []byte
 
    shm      bool
    fnLogger func(...interface{})
}
 
// NewReciever new recv
func NewReciever(url string, out chan<- []byte, shm bool, fn func(...interface{})) *Reciever {
    return &Reciever{
        ipcURL:   url,
        out:      out,
        shm:      shm,
        fnLogger: fn,
    }
}
 
// Run run a IPC client
func (r *Reciever) Run(ctx context.Context) {
 
    if r.shm {
        r.runShm(ctx)
    } else {
        r.run(ctx, deliver.NewClient(mode, r.ipcURL))
    }
}
 
func (r *Reciever) run(ctx context.Context, i deliver.Deliver) {
 
    count := 0
 
    for {
        select {
        case <-ctx.Done():
            i.Close()
            return
        default:
 
            if r.shm {
                if d, err := i.Recv(); err != nil {
                    i.Close()
                    r.fnLogger("Reciever RECV ERROR: ", err)
 
                    c, err := deliver.NewServerWithError(deliver.Shm, r.ipcURL)
                    for {
                        if err == nil {
                            break
                        }
                        r.fnLogger("Reciever CREATE FAILED : ", err)
                        time.Sleep(time.Second)
                        c, err = deliver.NewServerWithError(deliver.Shm, r.ipcURL)
                    }
                    i = c
                    r.fnLogger("Reciever CREATE SHM")
                } else {
                    if d != nil {
                        count++
                        if count > 10 {
                            count = 0
                            r.fnLogger("~~~shm recv image:", len(d))
                        }
                        if len(d) > 2 {
                            r.out <- d
                        }
                    }
                }
            } else {
                if msg, err := i.Recv(); err != nil {
                    // logo.Errorln("recv error : ", err, " url: ", r.ipcURL)
                } else {
                    count++
                    if count > 10 {
                        count = 0
                        r.fnLogger("~~~mangos recv image:", len(msg))
                    }
                    if len(msg) > 2 {
                        r.out <- msg
                    }
                }
            }
            time.Sleep(10 * time.Millisecond)
        }
    }
}
 
func (r *Reciever) runShm(ctx context.Context) {
    c, err := deliver.NewServerWithError(deliver.Shm, r.ipcURL)
    for {
        if err == nil {
            break
        }
        r.fnLogger("Reciever CLIENT CREATE FAILED : ", err)
        time.Sleep(1 * time.Second)
        c, err = deliver.NewServerWithError(deliver.Shm, r.ipcURL)
    }
    r.run(ctx, c)
}