2020年3月10日 星期二

程式效能之路(1) 變數宣告的時機影響記憶體分配的次數

情境: 每次loop都需要新的變數來進行運算,且為確保每次運算獨立,所以在每進入loop就重新宣告(配置)變數。


func () test() {
    for i := 0; i < 1000000000; i++ {
        var (
            v11, v12, v13, v21, v22, v23 float64
        )
        //...
        //...
        //...
    }
}
這樣看似平常,但在每次loop都會進行記憶體分配與釋放,都是很花費cpu time。


所以應調整成如下:
func () test() {
    var (
        v11, v12, v13, v21, v22, v23 float64

        initVar = func() {
            v11, v12, v13, v21, v22, v23 = 0, 0, 0, 0, 0, 0
        }
    )

    for i := 0; i < 1000000000; i++ {
        initVar()
        //...
        //...
        //...
    }
}
只有進loop時做宣告(配置)變數,而在每次loop開始將變數初始化

golang inner func() 讓code變優雅變精巧


原始 for loop裡在進入時會進行許多的資料判別是否可以往下運行。程式看起來非常的冗長
func (a *ArbTriangular) stg() {
    var (
        askDetph   map[string]db.Order10Depth
        lastTicker map[string]db.LastTicker
    )
    // ...
    // ...
    // ...
    for _, st := range *a.sTriangular {
        if st.isTrading {
            continue
        }
        if _, b := askDetph[st.a]; !b {
            continue
        }
        if _, b := askDetph[st.b]; !b {
            continue
        }
        if _, b := askDetph[st.c]; !b {
            continue
        }
        if _, b := lastTicker[st.a]; !b {
            continue
        }
        if _, b := lastTicker[st.b]; !b {
            continue
        }
        if _, b := lastTicker[st.c]; !b {
            continue
        }
        // ...
        // ...
        // ...
    }
}

進行一次的重構,for loop 看起來好多了,但是冗長的if判別看起來還是不夠優雅
func (a *ArbTriangular) stg() {
    var (
        askDetph map[string]db.Order10Depth
        bidDetph map[string]db.Order10Depth
    )
    checkData := func(st SymboleTriangular) (b bool) {
        if st.isTrading {
            return
        }
        if _, b = askDetph[st.a]; !b {
            return
        }
        if _, b = askDetph[st.b]; !b {
            return
        }
        if _, b = askDetph[st.c]; !b {
            return
        }
        if _, b = bidDetph[st.a]; !b {
            return
        }
        if _, b = bidDetph[st.b]; !b {
            return
        }
        if _, b = bidDetph[st.c]; !b {
            return
        }
        b = true
        return
    }
    //...
    //...
    //...
    for _, st := range *a.sTriangular {
        if !checkData(st) {
            continue
        }
        //...
        //...
        //...
    }
}

進行第二次的重構,這樣的成果優雅又精簡巧
func (a *ArbTriangular) stg() {
    var (
        askDetph map[string]db.Order10Depth
        bidDetph map[string]db.Order10Depth

        existAsk = func(s string) (b bool) {
            _, b = askDetph[s]
            return
        }
        existBid = func(s string) (b bool) {
            _, b = bidDetph[s]
            return
        }
        checkData = func(st SymboleTriangular) bool {
            if st.isTrading ||
                !existAsk(st.a) || !existAsk(st.b) || !existAsk(st.c) ||
                !existBid(st.a) || !existBid(st.b) || !existBid(st.c) {
                return false
            }
            return true
        }
    )
    //...
    //...
    //...
    for _, st := range *a.sTriangular {
        if !checkData(st) {
            continue
        }
        //...
        //...
        //...
    }
}

2020年3月2日 星期一

golang mongodb bson.M 如何解析多維陣列(multi-dimension slice : [][]interfae{}),或未知欄位數的資料?

mangodb中一維的資料可以採用 []interface{}來轉換取出,如下例:
    type User struct {
        Id_     bson.ObjectId `bson:"_id"`
        Name    string        `bson:"name"`
        Age     int           `bson:"age"`
        Friends []interface{} `bson:"friends"`
    }



但是若mondodb中的Friends記錄的是多維的資料,如: [][][]interface{}
確無法單純把定義改為如下,雖然程式執行不會有錯誤,但是資料內容確只有一個空的slice。
    type User struct {
        Id_     bson.ObjectId     `bson:"_id"`
        Name    string            `bson:"name"`
        Age     int               `bson:"age"`
        Friends [][][]interface{} `bson:"friends"`
    }

或,單一interface{}去接資料,也只是得到一個nil。
    type User struct {
        Id_     bson.ObjectId `bson:"_id"`
        Name    string        `bson:"name"`
        Age     int           `bson:"age"`
        Friends interface{}   `bson:"friends"`
    }

解決方式: 不定義結構,先用 interface{}將所有欄位資料取回再後續處理
func GetData() {
    var i interface{}
    var err error
    if i, err = mgoDao.GetMongoData(); err == nil && i != nil {
        if reflect.TypeOf(i.(bson.M)["friends"]) == reflect.TypeOf([]interface{}{}) {
            for _, arr1 := range i.(bson.M)["friends"].([]interface{}) {
                if reflect.TypeOf(arr1) == reflect.TypeOf([]interface{}{}) {
                    for _, arr2 := range arr1.([]interface{}) {
                        if reflect.TypeOf(arr2) == reflect.TypeOf([]interface{}{}) {
                            if len(arr2.([]interface{})) > 2 {
                                friendName := fmt.Sprintf("%v", arr2.([]interface{})[0])
                                friendTel := fmt.Sprintf("%v", arr2.([]interface{})[1])
                                friendDesc := fmt.Sprintf("%v", arr2.([]interface{})[2])
                                if debugLog {
                                    stdLog.Println(tools.GoID(), friendName, friendTel, friendDesc)
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return
}




如何對sql 查詢select不重覆的資料

不論concurrency併發 或 parallelism平行,  coroutine協程、multi-thread線程 或multi-process行程, 甚至corss-platform跨平台(可視為多行程),的向同一資料表以相同條件query select 不重複資料。也就是單一應用情境取出不重複資料。

案例:將大量資料取出並加以運算後傳到其它系統。

解決方式,有二個關鍵。
一是不論多協程,多線程或多行程,都必需加上lock,以確保不會有同時query的狀況。
二是,查詢出來後加上標記,以確保不會被其它查詢取出。

lock:
1.若只是multi-thread的程式,可以採用程式用mutex lock再加上一些技巧來完成。
2.但是若是multi-process 甚至corss-platform的多程式,就要使用database的lock機制。此例,建議採用user lock(mysql: select get_lock), app resource lock(mssql: sp_getapplock)。不建議採用row lock或table lock,這會導致其它應用也無法取得此資料。

加上已讀取標記
1.multi-thread 或 coroutine (goroutine):
程式只會在一個平台執行單一行程(process),而行程中可以多執行緒併發執行。而此標記可以做在程式裡,以減少db io,提供執行效率。
2.若是multi-process行程 或corss-platform跨平台,就只能在每次查詢出來後,對每一筆update加上標記。若考慮執行效率,可以採用redis記錄讀取標記,以減少db io。

mysql user lock

    defer func() {
        if tx != nil {
            if getLock == 1 && releaseLock == 0 {
                releaseLock, _ = tx.ReleaseSessionLock(SESSION_LOCK_KEY)
            }
            if err != nil {
                if errRollback := tx.Rollback(); errRollback != nil {
                    err = errors.New(err.Error() + "\n" + errRollback.Error())
                }
            }
        }
    }()
    if tx, err = dao.Begin(); err == nil {
        if getLock, err = tx.GetSessionLock(SESSION_LOCK_KEY, mysqlLockTimeout); err == nil && getLock == 1 {
            myJobs.IncWorkingJob()
            defer myJobs.DecWorkingJob()
            if datas, err = tx.GetData(procLimit, realmLocate); err == nil && kwds != nil {
                if releaseLock, err = tx.ReleaseSessionLock(SESSION_LOCK_KEY); err == nil {
                    rIDs, nIDs := DataProcess(datas)
                    if rIDs != "" { //完成
                        removeIdx(rIDs)
                    }
                    if err == nil && nIDs != "" { //未完成
                        removeIdx(nIDs)
                    }
                }
            }
        }
        if err == nil {
            if getLock == 1 && releaseLock == 0 {
                releaseLock, _ = tx.ReleaseSessionLock(SESSION_LOCK_KEY)
            }
            err = tx.Commit()
        }
    }


func (t *MyTx) GetData(l, r int) (datas []Data, err error) {
    sqlStr := "SELECT idx, f1, f2 FROM " + dataTb + " WHERE dt is null"
    if lenIdx() > 0 {
        sqlStr += " AND idx not in " + whereIdx()
    }
    sqlStr += " ORDER BY RAND() LIMIT ?"
    if rows, e := t.Query(sqlStr, l); e != nil {
        errLog.Println(tools.GoID(), dataTb, e)
        err = e
    } else {
        for rows.Next() {
            data := Data{}
            if err = rows.Scan(tools.Strut2Slice(&data)...); err == nil {
                kwds = append(datas, data)
                addIdx(strconv.FormatUint(data.IDx, 10))
            } else {
                errLog.Println(tools.GoID(), dataTb, err)
            }
        }
    }
    return
}
func whereIdx() (s string) {
    selectedIdxLock.Lock()
    defer selectedIdxLock.Unlock()
    s = ""
    for k := range selectedIdx {
        s += k + ","
    }
    s = strings.Trim(s, ",")
    if s != "" {
        s = "(" + s + ")"
    }
    return
}
func lenIdx() int {
    selectedIdxLock.Lock()
    defer selectedIdxLock.Unlock()
    return len(selectedIdx)
}
func addIdx(s string) {
    selectedIdxLock.Lock()
    defer selectedIdxLock.Unlock()
    selectedIdx[s] = true
}
func resetIdx() {
    selectedIdxLock.Lock()
    defer selectedIdxLock.Unlock()
    selectedIdx = make(map[string]bool)
}
func removeIdx(s string) {
    selectedIdxLock.Lock()
    defer selectedIdxLock.Unlock()
    if s != "" {
        ids := strings.Split(s, ",")
        for _, id := range ids {
            delete(selectedIdx, id)
        }
    }
}