8113758568
Background: With current design, the content backend uses key-lock for long-lived write transaction. If the content reference has been marked for write transaction, the other requestes on the same reference will fail fast with unavailable error. Since the metadata plugin is based on boltbd which only supports single-writer, the content backend can't block or handle the request too long. It requires the client to handle retry by itself, like OpenWriter - backoff retry helper. But the maximum retry interval can be up to 2 seconds. If there are several concurrent requestes fo the same image, the waiters maybe wakeup at the same time and there is only one waiter can continue. A lot of waiters will get into sleep and we will take long time to finish all the pulling jobs and be worse if the image has many more layers, which mentioned in issue #4937. After fetching, containerd.Pull API allows several hanlers to commit same ChainID snapshotter but only one can be done successfully. Since unpack tar.gz is time-consuming job, it can impact the performance on unpacking for same ChainID snapshotter in parallel. For instance, the Request 2 doesn't need to prepare and commit, it should just wait for Request 1 finish, which mentioned in pull request #6318. ```text Request 1 Request 2 Prepare | | | | Prepare Commit | | | | Commit(failed on exist) ``` Both content backoff retry and unnecessary unpack impacts the performance. Solution: Introduced the duplicate suppression in fetch and unpack context. The deplicate suppression uses key-mutex and single-waiter-notify to support singleflight. The caller can use the duplicate suppression in different PullImage handlers so that we can avoid unnecessary unpack and spin-lock in OpenWriter. Test Result: Before enhancement: ```bash ➜ /tmp sudo bash testing.sh "localhost:5000/redis:latest" 20 crictl pull localhost:5000/redis:latest (x20) takes ... real 1m6.172s user 0m0.268s sys 0m0.193s docker pull localhost:5000/redis:latest (x20) takes ... real 0m1.324s user 0m0.441s sys 0m0.316s ➜ /tmp sudo bash testing.sh "localhost:5000/golang:latest" 20 crictl pull localhost:5000/golang:latest (x20) takes ... real 1m47.657s user 0m0.284s sys 0m0.224s docker pull localhost:5000/golang:latest (x20) takes ... real 0m6.381s user 0m0.488s sys 0m0.358s ``` With this enhancement: ```bash ➜ /tmp sudo bash testing.sh "localhost:5000/redis:latest" 20 crictl pull localhost:5000/redis:latest (x20) takes ... real 0m1.140s user 0m0.243s sys 0m0.178s docker pull localhost:5000/redis:latest (x20) takes ... real 0m1.239s user 0m0.463s sys 0m0.275s ➜ /tmp sudo bash testing.sh "localhost:5000/golang:latest" 20 crictl pull localhost:5000/golang:latest (x20) takes ... real 0m5.546s user 0m0.217s sys 0m0.219s docker pull localhost:5000/golang:latest (x20) takes ... real 0m6.090s user 0m0.501s sys 0m0.331s ``` Test Script: localhost:5000/{redis|golang}:latest is equal to docker.io/library/{redis|golang}:latest. The image is hold in local registry service by `docker run -d -p 5000:5000 --name registry registry:2`. ```bash image_name="${1}" pull_times="${2:-10}" cleanup() { ctr image rmi "${image_name}" ctr -n k8s.io image rmi "${image_name}" crictl rmi "${image_name}" docker rmi "${image_name}" sleep 2 } crictl_testing() { for idx in $(seq 1 ${pull_times}); do crictl pull "${image_name}" > /dev/null 2>&1 & done wait } docker_testing() { for idx in $(seq 1 ${pull_times}); do docker pull "${image_name}" > /dev/null 2>&1 & done wait } cleanup > /dev/null 2>&1 echo 3 > /proc/sys/vm/drop_caches sleep 3 echo "crictl pull $image_name (x${pull_times}) takes ..." time crictl_testing echo echo 3 > /proc/sys/vm/drop_caches sleep 3 echo "docker pull $image_name (x${pull_times}) takes ..." time docker_testing ``` Fixes: #4937 Close: #4985 Close: #6318 Signed-off-by: Wei Fu <fuweid89@gmail.com>
106 lines
2.0 KiB
Go
106 lines
2.0 KiB
Go
/*
|
|
Copyright The containerd Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
// Package kmutex provides synchronization primitives to lock/unlock resource by unique key.
|
|
package kmutex
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
|
|
"golang.org/x/sync/semaphore"
|
|
)
|
|
|
|
// KeyedLocker is the interface for acquiring locks based on string.
|
|
type KeyedLocker interface {
|
|
Lock(ctx context.Context, key string) error
|
|
Unlock(key string)
|
|
}
|
|
|
|
func New() KeyedLocker {
|
|
return newKeyMutex()
|
|
}
|
|
|
|
func newKeyMutex() *keyMutex {
|
|
return &keyMutex{
|
|
locks: make(map[string]*klock),
|
|
}
|
|
}
|
|
|
|
type keyMutex struct {
|
|
mu sync.Mutex
|
|
|
|
locks map[string]*klock
|
|
}
|
|
|
|
type klock struct {
|
|
*semaphore.Weighted
|
|
ref int
|
|
}
|
|
|
|
func (km *keyMutex) Lock(ctx context.Context, key string) error {
|
|
km.mu.Lock()
|
|
|
|
l, ok := km.locks[key]
|
|
if !ok {
|
|
km.locks[key] = &klock{
|
|
Weighted: semaphore.NewWeighted(1),
|
|
}
|
|
l = km.locks[key]
|
|
}
|
|
l.ref++
|
|
km.mu.Unlock()
|
|
|
|
if err := l.Acquire(ctx, 1); err != nil {
|
|
km.mu.Lock()
|
|
defer km.mu.Unlock()
|
|
|
|
l.ref--
|
|
|
|
if l.ref < 0 {
|
|
panic(fmt.Errorf("kmutex: release of unlocked key %v", key))
|
|
}
|
|
|
|
if l.ref == 0 {
|
|
delete(km.locks, key)
|
|
}
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (km *keyMutex) Unlock(key string) {
|
|
km.mu.Lock()
|
|
defer km.mu.Unlock()
|
|
|
|
l, ok := km.locks[key]
|
|
if !ok {
|
|
panic(fmt.Errorf("kmutex: unlock of unlocked key %v", key))
|
|
}
|
|
l.Release(1)
|
|
|
|
l.ref--
|
|
|
|
if l.ref < 0 {
|
|
panic(fmt.Errorf("kmutex: released of unlocked key %v", key))
|
|
}
|
|
|
|
if l.ref == 0 {
|
|
delete(km.locks, key)
|
|
}
|
|
}
|