Writing the first block of each chunk to a two-dimensional page will open 64 Page

[T-TRz879]

I want to add this:
When I test the writing of a large file, the file will be split into chunks according to 64MB. We all know this. Every time I write data to c.pages[][], when indx is 0, it will be divided into 64 pages. From the second time, the BS will be set to 4MB. However, this operation will be performed in the next chunk. I think we can add the judgment of chunk off to avoid dividing into 64 shares each time the chunk indx is 0 (except the first chunk)
code
‘func (c *wChunk) WriteAt(p []byte, off int64) (n int, err error) {
if int(off)+len(p) > chunkSize {
return 0, fmt.Errorf("write out of chunk boudary: %d > %d", int(off)+len(p), chunkSize)
}
if off < int64(c.uploaded) {
return 0, fmt.Errorf("Cannot overwrite uploaded block: %d < %d", off, c.uploaded)
}

// Fill previous blocks with zeros
if c.length < int(off) {
	zeros := make([]byte, int(off)-c.length)
	_, _ = c.WriteAt(zeros, int64(c.length))
}

for n < len(p) {
	indx := c.index(int(off) + n)
	boff := (int(off) + n) % c.store.conf.BlockSize
	var bs = pageSize
	if indx > 0 || bs > c.store.conf.BlockSize { // here
		bs = c.store.conf.BlockSize
	}
	bi := boff / bs
	bo := boff % bs
	var page *Page
	if bi < len(c.pages[indx]) {
		page = c.pages[indx][bi]
	} else {
		page = allocPage(bs)
		page.Data = page.Data[:0]
		c.pages[indx] = append(c.pages[indx], page)
	}
	left := len(p) - n
	if bo+left > bs {
		page.Data = page.Data[:bs]
	} else if len(page.Data) < bo+left {
		page.Data = page.Data[:bo+left]
	}
	n += copy(page.Data[bo:], p[n:])
}
if int(off)+n > c.length {
	c.length = int(off) + n
}
return n, nil

}’

Why is this needed:
In this way, all chunks except the first write of the first chunk are written to the page in 4MB. This can speed up some speed

[davies]

For a new file, we don't know how much data will be written, it's expensive to allow 4MB of memory if only 4KB data will be written. These 64KB pages is used to allocate memory more efficently in case of we don't know how much data will be written.

[T-TRz879]

I see what you mean, but after a large file arrives, the first allocation of 64KB can be understood. After the first chunk of the same large file ends, the first call after each new chunk allocated will use 64KB instead of 4MB. I think the first chunk can use 64KB for the first time, and 4MB can be used in the future

[T-TRz879]

@davies i need you help,this question disturb me some days