메서드 실행 중 높은 메모리 소비

Question

프로젝트의 경우 약 5 천만 개의 CSV 행 각각에 대한 구조체를 수동으로 만들고 싶습니다. 이를 위해 파일을 한 줄씩 반복하고 각 구조체를 슬라이스에 추가합니다. 이것은 멍청한 방법입니다.

func readCSV(filePath string) DataFrame {
    file, _ := os.Open(filePath)
    defer file.Close()
    var rows []Row
    scanner := bufio.NewScanner(file)
    scanner.Scan()
    for scanner.Scan() {
        parts := strings.Split(scanner.Text(), ",")
        if len(parts) < 7 {
            continue
        }
        column1, _ := strconv.Atoi(parts[0])
        column2, _ := strconv.ParseFloat(parts[1], 32)
        column3, _ := strconv.ParseFloat(parts[2], 32)
        column4 := parts[3]
        column5, _ := strconv.ParseFloat(parts[4], 32)
        column6 := parts[5]
        column7 := parts[6]
        row := Row{
            Column1: column1,
            Column2: column2,
            Column3: column3,
            Column4: column4,
            Column5: column5,
            Column6: column6,
            Column7: column7,
        }
        rows = append(rows, row)
    }
    return DataFrame{
        Rows: rows,
    }
}

결과 DataFrame에는 약 3GB의 메모리가 있습니다. 문제는 메소드 실행 중에 RAM 소비가 지붕을 통과하고 Go 프로세스가 15GB 이상의 메모리를 사용하여 내 목적에 맞게 기능을 사용할 수 없다는 것입니다. 슬라이스가 반환되면 프로세스의 RAM 사용량이 예상 3GB로 떨어집니다.

힙 프로필은 다음과 같습니다.

    3.26GB     5.81GB (flat, cum)   100% of Total
         .          .     62:   scanner := bufio.NewScanner(file)
         .          .     63:   scanner.Scan()
         .          .     64:   for scanner.Scan() {
         .     2.55GB     65:           parts := strings.Split(scanner.Text(), ",")
         .          .     66:           if len(parts) < 7 {
         .          .     67:                   continue
         .          .     68:           }
         .          .     69:           column1, _ := strconv.Atoi(parts[0])
         .          .     70:           column2, _ := strconv.ParseFloat(parts[1], 32)
         .          .     71:           column3, _ := strconv.ParseFloat(parts[2], 32)
         .          .     72:           column4 := parts[3]
         .          .     73:           column5, _ := strconv.ParseFloat(parts[4], 32)
         .          .     74:           column6 := parts[5]
         .          .     75:           column7 := parts[6]
         .          .     76:           row := Row{
         .          .     77:                   Column1: column1,
         .          .     78:                   Column2: column2,
         .          .     79:                   Column3: column3,
         .          .     80:                   Column4: column4,
         .          .     81:                   Column5: column5,
         .          .     82:                   Column6: column6,
         .          .     83:                   Column7: column7,
         .          .     84:           }
    3.26GB     3.26GB     85:           rows = append(rows, row)
         .          .     86:   }
         .          .     87:
         .          .     88:   return DataFrame{
         .          .     89:           Rows: rows,

나는 높은 RAM 소비가 어디에서 오는지 알 수 없습니다. 성공하지 못한 채 가비지 수집기를 수동으로 호출하려고했습니다. 누구든지 나에게 힌트를 줄 수 있습니까?

Answer 1

rows포인터가 아닌 Row 구조체의 배열입니다. 각 행의 비용은 부동 소수점 및 정수에 대해 32 바이트이며 문자열의 길이에 관계없이입니다. 5 천만 개의 행이 상당히 커질 수 있습니다. 더 나쁜 것은 약 1.5 배 append증가 rows하여 많은 추가 메모리를 할당하고 가비지 수집이 필요한 많은 작은 버전을 버릴 수 있습니다. 그리고 append(rows, row)더 많은 할당과 할당 해제를 의미하는 복사본입니다. 그리고 메모리 사용량을 늘리는 가비지 수집을 기다려야합니다.

대신 참조를 저장하여 피할 수 있습니다. 이것은 더 적은 할당을 의미하고 rows훨씬 더 작아야합니다.

var rows []*Row
...
rows = append(rows, &row)

---

그러나 진짜 문제는 모든 것을 한꺼번에 넣는 것입니다. Go입니다! 채널 과 고 루틴 을 사용 하여 처리와 함께 한 번에 한 행을 동시에 읽을 수 있습니다 .

CSV는 믿을 수 없을 정도로 까다 롭습니다. Go에는 이미 CSV 라이브러리 인 encoding / csv 가 있으므로 사용하겠습니다.

# A handy function to make ignoring errors a bit less laborious.
func IgnoreError(value interface{}, err error) interface{} {
    return value
}

# Its more flexible to take an io.Reader.
# It returns a channel of individual rows.
func readCSV(input io.Reader) chan Row {
    rows := make(chan Row)
    go func() {
        defer close(rows)

        # Use encoding/csv.
        # Let it reuse its backing array for each row.
        # Ignore rows with the wrong number of columns.
        reader := csv.NewReader(input)
        reader.FieldsPerRecord = 7
        reader.ReuseRecord = true

        for {
            parts, err := reader.Read()

            if err == io.EOF {
                break
            }
            if err != nil {
                continue
            }

            # Send each row down the channel.
            rows <- Row{
                Column1: IgnoreError(strconv.Atoi(parts[0])).(int),
                Column2: IgnoreError(strconv.ParseFloat(parts[1], 32)).(float64),
                Column3: IgnoreError(strconv.ParseFloat(parts[2], 32)).(float64),
                Column4: parts[3],
                Column5: IgnoreError(strconv.ParseFloat(parts[4], 32)).(float64),
                Column6: parts[5],
                Column7: parts[6],
            }
        }
    }();
    
    return rows;
}

func main() {
    file, err := os.Open("test.csv")
    if err != nil {
        log.Fatal(err)
    }
    
    rows := readCSV(file)
    for row := range rows {
        fmt.Println(row)
    }
}

이제 한 번에 하나의 행만로드됩니다. 메모리 사용량은 일정해야합니다.