From 97f714e375ad4facf300c70943491861b7562051 Mon Sep 17 00:00:00 2001 From: char-1ee Date: Tue, 20 Feb 2024 10:04:37 -0700 Subject: [PATCH] Test --- ctriface/iface.go | 11 +- ctriface/iface_test.go | 533 ++++++++++++++++--------------- ctriface/orch.go | 16 +- go.mod | 2 + go.sum | 2 - lg/uni_logger.go | 17 + memory/manager/manager.go | 11 +- memory/manager/snapshot_state.go | 11 +- 8 files changed, 318 insertions(+), 285 deletions(-) create mode 100644 lg/uni_logger.go diff --git a/ctriface/iface.go b/ctriface/iface.go index 4a335c9ef..298546742 100644 --- a/ctriface/iface.go +++ b/ctriface/iface.go @@ -24,6 +24,7 @@ package ctriface import ( "context" + "encoding/json" "os" "os/exec" "path/filepath" @@ -523,6 +524,9 @@ func (o *Orchestrator) LoadSnapshot(ctx context.Context, originVmID string, vmID go func() { defer close(loadDone) + confStr, _ := json.Marshal(conf) + logger.Debugf("TEST: CreateVM request: %s", confStr) + if _, loadErr := o.fcClient.CreateVM(ctx, conf); loadErr != nil { logger.Error("Failed to load snapshot of the VM: ", loadErr) logger.Errorf("snapFilePath: %s, memFilePath: %s, newSnapshotPath: %s", snap.GetSnapshotFilePath(), snap.GetMemFilePath(), containerSnap.GetDevicePath()) @@ -552,9 +556,11 @@ func (o *Orchestrator) LoadSnapshot(ctx context.Context, originVmID string, vmID }() logger.Debug("TEST: CreatVM request sent") + <-loadDone + if o.GetUPFEnabled() { - logger.Debug("TEST: Registering VM with the memory manager") + logger.Debug("TEST: Registering VM with snap with the memory manager") stateCfg := manager.SnapshotStateCfg{ VMID: vmID, @@ -570,12 +576,13 @@ func (o *Orchestrator) LoadSnapshot(ctx context.Context, originVmID string, vmID logger.Error(err, "failed to register new VM with memory manager") } + logger.Debug("TEST: activate VM in mm") if activateErr = o.memoryManager.Activate(vmID); activateErr != nil { logger.Warn("Failed to activate VM in the memory manager", activateErr) } } - <-loadDone + // <-loadDone loadSnapshotMetric.MetricMap[metrics.LoadVMM] = metrics.ToUS(time.Since(tStart)) diff --git a/ctriface/iface_test.go b/ctriface/iface_test.go index 47c377e88..677dc9d1e 100644 --- a/ctriface/iface_test.go +++ b/ctriface/iface_test.go @@ -24,9 +24,7 @@ package ctriface import ( "context" "flag" - "fmt" - "os" - "sync" + "os" "testing" "time" @@ -35,6 +33,8 @@ import ( log "github.com/sirupsen/logrus" "github.com/stretchr/testify/require" "github.com/vhive-serverless/vhive/snapshotting" + + "github.com/vhive-serverless/vhive/lg" ) // TODO: Make it impossible to use lazy mode without UPF @@ -68,8 +68,18 @@ func TestStartSnapStop(t *testing.T) { ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) defer cancel() + // uffdSockAddr := "/tmp/uffd.sock" + // uffdSockDir := "/home/char/uffd" + // uffdSockAddr := uffdSockDir + "/uffd.sock" uffdSockAddr := "/tmp/uffd.sock" - orch := NewOrchestrator("devmapper", "", WithTestModeOn(true), WithUffdSockAddr(uffdSockAddr)) + orch := NewOrchestrator( + "devmapper", + "", + WithTestModeOn(true), + WithSnapshots(true), + WithUPF(*isUPFEnabled), + WithUffdSockAddr(uffdSockAddr), + ) vmID := "2" @@ -83,6 +93,9 @@ func TestStartSnapStop(t *testing.T) { err = orch.CreateSnapshot(ctx, vmID, snap) require.NoError(t, err, "Failed to create snapshot of VM") + // _, err = orch.ResumeVM(ctx, vmID) + // require.NoError(t, err, "Failed to resume VM after created snapshot") + err = orch.StopSingleVM(ctx, vmID) require.NoError(t, err, "Failed to stop VM") @@ -92,6 +105,8 @@ func TestStartSnapStop(t *testing.T) { _, _, err = orch.LoadSnapshot(ctx, originVmID, vmID, snap) require.NoError(t, err, "Failed to load snapshot of VM") + log.Debug("TEST: LoadSnapshot completed") + lg.UniLogger.Println("This is a test") _, err = orch.ResumeVM(ctx, vmID) require.NoError(t, err, "Failed to resume VM") @@ -104,275 +119,275 @@ func TestStartSnapStop(t *testing.T) { orch.Cleanup() } -func TestPauseSnapResume(t *testing.T) { - log.SetFormatter(&log.TextFormatter{ - TimestampFormat: ctrdlog.RFC3339NanoFixed, - FullTimestamp: true, - }) - //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging - - log.SetOutput(os.Stdout) +// func TestPauseSnapResume(t *testing.T) { +// log.SetFormatter(&log.TextFormatter{ +// TimestampFormat: ctrdlog.RFC3339NanoFixed, +// FullTimestamp: true, +// }) +// //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging - log.SetLevel(log.DebugLevel) - - testTimeout := 120 * time.Second - ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) - defer cancel() - - orch := NewOrchestrator( - "devmapper", - "", - WithTestModeOn(true), - WithUPF(*isUPFEnabled), - WithLazyMode(*isLazyMode), - ) - - vmID := "4" - revision := "myrev-4" - - _, _, err := orch.StartVM(ctx, vmID, testImageName) - require.NoError(t, err, "Failed to start VM") - - err = orch.PauseVM(ctx, vmID) - require.NoError(t, err, "Failed to pause VM") - - snap := snapshotting.NewSnapshot(revision, "/fccd/snapshots", testImageName) - err = snap.CreateSnapDir() - require.NoError(t, err, "Failed to create snapshots directory") - - err = orch.CreateSnapshot(ctx, vmID, snap) - require.NoError(t, err, "Failed to create snapshot of VM") +// log.SetOutput(os.Stdout) - _, err = orch.ResumeVM(ctx, vmID) - require.NoError(t, err, "Failed to resume VM") +// log.SetLevel(log.DebugLevel) - err = orch.StopSingleVM(ctx, vmID) - require.NoError(t, err, "Failed to stop VM") +// testTimeout := 120 * time.Second +// ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) +// defer cancel() - _ = snap.Cleanup() - orch.Cleanup() -} +// orch := NewOrchestrator( +// "devmapper", +// "", +// WithTestModeOn(true), +// WithUPF(*isUPFEnabled), +// WithLazyMode(*isLazyMode), +// ) -func TestStartStopSerial(t *testing.T) { - log.SetFormatter(&log.TextFormatter{ - TimestampFormat: ctrdlog.RFC3339NanoFixed, - FullTimestamp: true, - }) - //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging +// vmID := "4" +// revision := "myrev-4" - log.SetOutput(os.Stdout) +// _, _, err := orch.StartVM(ctx, vmID, testImageName) +// require.NoError(t, err, "Failed to start VM") - log.SetLevel(log.InfoLevel) +// err = orch.PauseVM(ctx, vmID) +// require.NoError(t, err, "Failed to pause VM") - testTimeout := 120 * time.Second - ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) - defer cancel() +// snap := snapshotting.NewSnapshot(revision, "/fccd/snapshots", testImageName) +// err = snap.CreateSnapDir() +// require.NoError(t, err, "Failed to create snapshots directory") - orch := NewOrchestrator( - "devmapper", - "", - WithTestModeOn(true), - WithUPF(*isUPFEnabled), - WithLazyMode(*isLazyMode), - ) +// err = orch.CreateSnapshot(ctx, vmID, snap) +// require.NoError(t, err, "Failed to create snapshot of VM") - vmID := "5" +// _, err = orch.ResumeVM(ctx, vmID) +// require.NoError(t, err, "Failed to resume VM") - _, _, err := orch.StartVM(ctx, vmID, testImageName) - require.NoError(t, err, "Failed to start VM") +// err = orch.StopSingleVM(ctx, vmID) +// require.NoError(t, err, "Failed to stop VM") - err = orch.StopSingleVM(ctx, vmID) - require.NoError(t, err, "Failed to stop VM") +// _ = snap.Cleanup() +// orch.Cleanup() +// } - orch.Cleanup() -} +// func TestStartStopSerial(t *testing.T) { +// log.SetFormatter(&log.TextFormatter{ +// TimestampFormat: ctrdlog.RFC3339NanoFixed, +// FullTimestamp: true, +// }) +// //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging -func TestPauseResumeSerial(t *testing.T) { - log.SetFormatter(&log.TextFormatter{ - TimestampFormat: ctrdlog.RFC3339NanoFixed, - FullTimestamp: true, - }) - //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging +// log.SetOutput(os.Stdout) - log.SetOutput(os.Stdout) +// log.SetLevel(log.InfoLevel) - log.SetLevel(log.InfoLevel) +// testTimeout := 120 * time.Second +// ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) +// defer cancel() - testTimeout := 120 * time.Second - ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) - defer cancel() - - orch := NewOrchestrator( - "devmapper", - "", - WithTestModeOn(true), - WithUPF(*isUPFEnabled), - WithLazyMode(*isLazyMode), - ) - - vmID := "6" - - _, _, err := orch.StartVM(ctx, vmID, testImageName) - require.NoError(t, err, "Failed to start VM") - - err = orch.PauseVM(ctx, vmID) - require.NoError(t, err, "Failed to pause VM") - - _, err = orch.ResumeVM(ctx, vmID) - require.NoError(t, err, "Failed to resume VM") - - err = orch.StopSingleVM(ctx, vmID) - require.NoError(t, err, "Failed to stop VM") - - orch.Cleanup() -} - -func TestStartStopParallel(t *testing.T) { - log.SetFormatter(&log.TextFormatter{ - TimestampFormat: ctrdlog.RFC3339NanoFixed, - FullTimestamp: true, - }) - //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging - - log.SetOutput(os.Stdout) - - log.SetLevel(log.InfoLevel) - - testTimeout := 360 * time.Second - ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) - defer cancel() - - vmNum := 10 - vmIDBase := 7 - - orch := NewOrchestrator( - "devmapper", - "", - WithTestModeOn(true), - WithUPF(*isUPFEnabled), - WithLazyMode(*isLazyMode), - ) - - // Pull image - _, err := orch.getImage(ctx, testImageName) - require.NoError(t, err, "Failed to pull image "+testImageName) - - { - var vmGroup sync.WaitGroup - for i := vmIDBase; i < vmNum; i++ { - vmGroup.Add(1) - go func(i int) { - defer vmGroup.Done() - vmID := fmt.Sprintf("%d", i) - _, _, err := orch.StartVM(ctx, vmID, testImageName) - require.NoError(t, err, "Failed to start VM "+vmID) - }(i) - } - vmGroup.Wait() - } - - { - var vmGroup sync.WaitGroup - for i := vmIDBase; i < vmNum; i++ { - vmGroup.Add(1) - go func(i int) { - defer vmGroup.Done() - vmID := fmt.Sprintf("%d", i) - err := orch.StopSingleVM(ctx, vmID) - require.NoError(t, err, "Failed to stop VM "+vmID) - }(i) - } - vmGroup.Wait() - } - - orch.Cleanup() -} - -func TestPauseResumeParallel(t *testing.T) { - log.SetFormatter(&log.TextFormatter{ - TimestampFormat: ctrdlog.RFC3339NanoFixed, - FullTimestamp: true, - }) - //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging - - log.SetOutput(os.Stdout) - - log.SetLevel(log.InfoLevel) - - testTimeout := 120 * time.Second - ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) - defer cancel() - - vmNum := 10 - vmIDBase := 17 - - orch := NewOrchestrator( - "devmapper", - "", - WithTestModeOn(true), - WithUPF(*isUPFEnabled), - WithLazyMode(*isLazyMode), - ) - - // Pull image - _, err := orch.getImage(ctx, testImageName) - require.NoError(t, err, "Failed to pull image "+testImageName) - - { - var vmGroup sync.WaitGroup - for i := vmIDBase; i < vmNum; i++ { - vmGroup.Add(1) - go func(i int) { - defer vmGroup.Done() - vmID := fmt.Sprintf("%d", i) - _, _, err := orch.StartVM(ctx, vmID, testImageName) - require.NoError(t, err, "Failed to start VM") - }(i) - } - vmGroup.Wait() - } - - { - var vmGroup sync.WaitGroup - for i := vmIDBase; i < vmNum; i++ { - vmGroup.Add(1) - go func(i int) { - defer vmGroup.Done() - vmID := fmt.Sprintf("%d", i) - err := orch.PauseVM(ctx, vmID) - require.NoError(t, err, "Failed to pause VM") - }(i) - } - vmGroup.Wait() - } - - { - var vmGroup sync.WaitGroup - for i := vmIDBase; i < vmNum; i++ { - vmGroup.Add(1) - go func(i int) { - defer vmGroup.Done() - vmID := fmt.Sprintf("%d", i) - _, err := orch.ResumeVM(ctx, vmID) - require.NoError(t, err, "Failed to resume VM") - }(i) - } - vmGroup.Wait() - } - - { - var vmGroup sync.WaitGroup - for i := vmIDBase; i < vmNum; i++ { - vmGroup.Add(1) - go func(i int) { - defer vmGroup.Done() - vmID := fmt.Sprintf("%d", i) - err := orch.StopSingleVM(ctx, vmID) - require.NoError(t, err, "Failed to stop VM") - }(i) - } - vmGroup.Wait() - } - - orch.Cleanup() -} +// orch := NewOrchestrator( +// "devmapper", +// "", +// WithTestModeOn(true), +// WithUPF(*isUPFEnabled), +// WithLazyMode(*isLazyMode), +// ) + +// vmID := "5" + +// _, _, err := orch.StartVM(ctx, vmID, testImageName) +// require.NoError(t, err, "Failed to start VM") + +// err = orch.StopSingleVM(ctx, vmID) +// require.NoError(t, err, "Failed to stop VM") + +// orch.Cleanup() +// } + +// func TestPauseResumeSerial(t *testing.T) { +// log.SetFormatter(&log.TextFormatter{ +// TimestampFormat: ctrdlog.RFC3339NanoFixed, +// FullTimestamp: true, +// }) +// //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging + +// log.SetOutput(os.Stdout) + +// log.SetLevel(log.InfoLevel) + +// testTimeout := 120 * time.Second +// ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) +// defer cancel() + +// orch := NewOrchestrator( +// "devmapper", +// "", +// WithTestModeOn(true), +// WithUPF(*isUPFEnabled), +// WithLazyMode(*isLazyMode), +// ) + +// vmID := "6" + +// _, _, err := orch.StartVM(ctx, vmID, testImageName) +// require.NoError(t, err, "Failed to start VM") + +// err = orch.PauseVM(ctx, vmID) +// require.NoError(t, err, "Failed to pause VM") + +// _, err = orch.ResumeVM(ctx, vmID) +// require.NoError(t, err, "Failed to resume VM") + +// err = orch.StopSingleVM(ctx, vmID) +// require.NoError(t, err, "Failed to stop VM") + +// orch.Cleanup() +// } + +// func TestStartStopParallel(t *testing.T) { +// log.SetFormatter(&log.TextFormatter{ +// TimestampFormat: ctrdlog.RFC3339NanoFixed, +// FullTimestamp: true, +// }) +// //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging + +// log.SetOutput(os.Stdout) + +// log.SetLevel(log.InfoLevel) + +// testTimeout := 360 * time.Second +// ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) +// defer cancel() + +// vmNum := 10 +// vmIDBase := 7 + +// orch := NewOrchestrator( +// "devmapper", +// "", +// WithTestModeOn(true), +// WithUPF(*isUPFEnabled), +// WithLazyMode(*isLazyMode), +// ) + +// // Pull image +// _, err := orch.getImage(ctx, testImageName) +// require.NoError(t, err, "Failed to pull image "+testImageName) + +// { +// var vmGroup sync.WaitGroup +// for i := vmIDBase; i < vmNum; i++ { +// vmGroup.Add(1) +// go func(i int) { +// defer vmGroup.Done() +// vmID := fmt.Sprintf("%d", i) +// _, _, err := orch.StartVM(ctx, vmID, testImageName) +// require.NoError(t, err, "Failed to start VM "+vmID) +// }(i) +// } +// vmGroup.Wait() +// } + +// { +// var vmGroup sync.WaitGroup +// for i := vmIDBase; i < vmNum; i++ { +// vmGroup.Add(1) +// go func(i int) { +// defer vmGroup.Done() +// vmID := fmt.Sprintf("%d", i) +// err := orch.StopSingleVM(ctx, vmID) +// require.NoError(t, err, "Failed to stop VM "+vmID) +// }(i) +// } +// vmGroup.Wait() +// } + +// orch.Cleanup() +// } + +// func TestPauseResumeParallel(t *testing.T) { +// log.SetFormatter(&log.TextFormatter{ +// TimestampFormat: ctrdlog.RFC3339NanoFixed, +// FullTimestamp: true, +// }) +// //log.SetReportCaller(true) // FIXME: make sure it's false unless debugging + +// log.SetOutput(os.Stdout) + +// log.SetLevel(log.InfoLevel) + +// testTimeout := 120 * time.Second +// ctx, cancel := context.WithTimeout(namespaces.WithNamespace(context.Background(), namespaceName), testTimeout) +// defer cancel() + +// vmNum := 10 +// vmIDBase := 17 + +// orch := NewOrchestrator( +// "devmapper", +// "", +// WithTestModeOn(true), +// WithUPF(*isUPFEnabled), +// WithLazyMode(*isLazyMode), +// ) + +// // Pull image +// _, err := orch.getImage(ctx, testImageName) +// require.NoError(t, err, "Failed to pull image "+testImageName) + +// { +// var vmGroup sync.WaitGroup +// for i := vmIDBase; i < vmNum; i++ { +// vmGroup.Add(1) +// go func(i int) { +// defer vmGroup.Done() +// vmID := fmt.Sprintf("%d", i) +// _, _, err := orch.StartVM(ctx, vmID, testImageName) +// require.NoError(t, err, "Failed to start VM") +// }(i) +// } +// vmGroup.Wait() +// } + +// { +// var vmGroup sync.WaitGroup +// for i := vmIDBase; i < vmNum; i++ { +// vmGroup.Add(1) +// go func(i int) { +// defer vmGroup.Done() +// vmID := fmt.Sprintf("%d", i) +// err := orch.PauseVM(ctx, vmID) +// require.NoError(t, err, "Failed to pause VM") +// }(i) +// } +// vmGroup.Wait() +// } + +// { +// var vmGroup sync.WaitGroup +// for i := vmIDBase; i < vmNum; i++ { +// vmGroup.Add(1) +// go func(i int) { +// defer vmGroup.Done() +// vmID := fmt.Sprintf("%d", i) +// _, err := orch.ResumeVM(ctx, vmID) +// require.NoError(t, err, "Failed to resume VM") +// }(i) +// } +// vmGroup.Wait() +// } + +// { +// var vmGroup sync.WaitGroup +// for i := vmIDBase; i < vmNum; i++ { +// vmGroup.Add(1) +// go func(i int) { +// defer vmGroup.Done() +// vmID := fmt.Sprintf("%d", i) +// err := orch.StopSingleVM(ctx, vmID) +// require.NoError(t, err, "Failed to stop VM") +// }(i) +// } +// vmGroup.Wait() +// } + +// orch.Cleanup() +// } diff --git a/ctriface/orch.go b/ctriface/orch.go index 121ddd2f8..8cc9cc6de 100644 --- a/ctriface/orch.go +++ b/ctriface/orch.go @@ -23,7 +23,6 @@ package ctriface import ( - "github.com/vhive-serverless/vhive/devmapper" "os" "os/signal" "path/filepath" @@ -32,6 +31,8 @@ import ( "syscall" "time" + "github.com/vhive-serverless/vhive/devmapper" + log "github.com/sirupsen/logrus" "github.com/containerd/containerd" @@ -88,7 +89,7 @@ type Orchestrator struct { isUPFEnabled bool isLazyMode bool snapshotsDir string - uffdSockAddr string + uffdSockAddr string isMetricsMode bool netPoolSize int @@ -122,14 +123,15 @@ func NewOrchestrator(snapshotter, hostIface string, opts ...OrchestratorOption) } if o.GetUPFEnabled() { - _, err = os.Create(o.uffdSockAddr) + file, err := os.Create(o.uffdSockAddr) if err != nil { - log.Fatal("TEST: failed to create uffd sock", err) + log.Fatalf("Failed to create socket file: %v", err) } - + defer file.Close() + managerCfg := manager.MemoryManagerCfg{ MetricsModeOn: o.isMetricsMode, - UffdSockAddr: o.uffdSockAddr, + UffdSockAddr: o.uffdSockAddr, } o.memoryManager = manager.NewMemoryManager(managerCfg) } @@ -218,7 +220,7 @@ func (o *Orchestrator) GetSnapshotsDir() string { // TODO: /tmp/uffd/firecracker-containerd#3-0/uffd.sock func (o *Orchestrator) getUffdSockAddr(vmID string) string { return filepath.Join(o.getVMBaseDir(vmID), "uffd.sock") -} +} func (o *Orchestrator) getSnapshotFile(vmID string) string { return filepath.Join(o.getVMBaseDir(vmID), "snap_file") diff --git a/go.mod b/go.mod index 9aca89c1d..6f116b3d1 100644 --- a/go.mod +++ b/go.mod @@ -40,9 +40,11 @@ replace ( replace ( github.com/firecracker-microvm/firecracker-containerd => ../firecracker-containerd + github.com/vhive-serverless/vhive/ctriface => ./ctriface // github.com/firecracker-microvm/firecracker-containerd => github.com/char-1ee/firecracker-containerd v0.0.0-20231018191519-49cac5eea134 github.com/vhive-serverless/vhive/examples/protobuf/helloworld => ./examples/protobuf/helloworld + github.com/vhive-serverless/vhive/lg => ./lg ) require ( diff --git a/go.sum b/go.sum index fd6b5eec0..20ae4a93e 100644 --- a/go.sum +++ b/go.sum @@ -147,8 +147,6 @@ github.com/cespare/prettybench v0.0.0-20150116022406-03b8cfe5406c/go.mod h1:Xe6Z github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chai2010/gettext-go v0.0.0-20160711120539-c6fed771bfd5/go.mod h1:/iP1qXHoty45bqomnu2LM+VVyAEdWN+vtSHGlQgyxbw= -github.com/char-1ee/firecracker-containerd v0.0.0-20231018191519-49cac5eea134 h1:InrwKCxhDU1PJTNJ0wOHM/PvsIruaz2HriViJ5swrX4= -github.com/char-1ee/firecracker-containerd v0.0.0-20231018191519-49cac5eea134/go.mod h1:XC5a/4PWbzipD5Ron745odZxoVy/J6d8xFldwTZJbSU= github.com/checkpoint-restore/go-criu v0.0.0-20190109184317-bdb7599cd87b/go.mod h1:TrMrLQfeENAPYPRsJuq3jsqdlRh3lvi6trTZJG8+tho= github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw= github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M= diff --git a/lg/uni_logger.go b/lg/uni_logger.go new file mode 100644 index 000000000..b8decb6a5 --- /dev/null +++ b/lg/uni_logger.go @@ -0,0 +1,17 @@ +package lg + +import ( + "log" + "os" + // log "github.com/sirupsen/logrus" +) + +var UniLogger *log.Logger + +func init() { + file, err := os.OpenFile("output.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) + if err != nil { + log.Fatalln("Failed to open log file:", err) + } + UniLogger = log.New(file, "DEBUG: ", log.Ldate|log.Ltime|log.Lshortfile) +} diff --git a/memory/manager/manager.go b/memory/manager/manager.go index c51e251d4..e48e1b39b 100644 --- a/memory/manager/manager.go +++ b/memory/manager/manager.go @@ -46,7 +46,7 @@ const ( // MemoryManagerCfg Global config of the manager type MemoryManagerCfg struct { MetricsModeOn bool - UffdSockAddr string // it could not be appropriate to put sock here + UffdSockAddr string // it could not be appropriate to put sock here } // MemoryManager Serves page faults coming from VMs @@ -54,9 +54,7 @@ type MemoryManager struct { sync.Mutex MemoryManagerCfg instances map[string]*SnapshotState // Indexed by vmID - origins map[string]string // Track parent vm for vm loaded from snapshot - - // TODO: snapshot and its children + origins map[string]string // Track parent vm for vm loaded from snapshot } // NewMemoryManager Initializes a new memory manager @@ -65,8 +63,9 @@ func NewMemoryManager(cfg MemoryManagerCfg) *MemoryManager { m := new(MemoryManager) m.instances = make(map[string]*SnapshotState) + m.origins = make(map[string]string) m.MemoryManagerCfg = cfg - + return m } @@ -397,7 +396,7 @@ func (m *MemoryManager) GetUPFLatencyStats(vmID string) ([]*metrics.Metric, erro return state.latencyMetrics, nil } -// Deprecated +// Deprecated // func (m *MemoryManager) GetUPFSockPath(vmID string, isSnapshotReady bool) (string, error) { // logger := log.WithFields(log.Fields{"vmID": vmID}) diff --git a/memory/manager/snapshot_state.go b/memory/manager/snapshot_state.go index 98fc14117..34e041918 100644 --- a/memory/manager/snapshot_state.go +++ b/memory/manager/snapshot_state.go @@ -44,6 +44,7 @@ import ( log "github.com/sirupsen/logrus" "golang.org/x/sys/unix" + "github.com/vhive-serverless/vhive/lg" "github.com/vhive-serverless/vhive/metrics" "unsafe" @@ -290,15 +291,7 @@ func (s *SnapshotState) pollUserPageFaults(readyCh chan int) { // TODO: config where the logger stream goes logger.Debug("Starting polling loop") - fmt.Printf("Starting polling loop") - - logFile, err := os.OpenFile("pg_happen.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666) - if err != nil { - log.Fatalf("error opening file: %v", err) - } - defer logFile.Close() - log.SetOutput(logFile) - log.Println("This is a test log entry") + lg.UniLogger.Println("Starting polling loop") defer syscall.Close(s.epfd)