pod: Improve pod create performances

In order to optimize pod creation, this patch does not wait for the
VM after it has been started. Instead, it will wait for it during the
"start" stage. This will allow our VM to be started while the caller
could potentially do other things between create and start. Globally,
this improves the boot time of our containers.
Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>

Author: Sebastien Boeuf

hypervisor.go

@@ -446,7 +446,8 @@ func RunningOnVMM(cpuInfoPath string) (bool, error) {
 typehypervisorinterface {
 init(pod*Pod) error
 createPod(podConfigPodConfig) error
-startPod(startCh, stopChchanstruct{}) error
+startPod() error
+waitPod(timeoutint) error
 stopPod() error
 pausePod() error
 resumePod() error

mock_hypervisor.go

@@ -36,9 +36,11 @@ func (m *mockHypervisor) createPod(podConfig PodConfig) error {
 returnnil
 }
 
-func (m*mockHypervisor) startPod(startCh, stopChchanstruct{}) error {
-varmsgstruct{}
-startCh<-msg
+func (m*mockHypervisor) startPod() error {
+returnnil
+}
+
+func (m*mockHypervisor) waitPod(timeoutint) error {
 returnnil
 }
 

mock_hypervisor_test.go

@@ -19,7 +19,6 @@ package virtcontainers
 import (
 "fmt"
 "testing"
-"time"
 )
 
 funcTestMockHypervisorInit(t*testing.T) {
@@ -36,8 +35,7 @@ func TestMockHypervisorInit(t *testing.T) {
 	}
 
 // wrong config
-err:=m.init(pod)
-iferr==nil {
+iferr:=m.init(pod); err==nil {
 t.Fatal()
 	}
 
@@ -48,8 +46,7 @@ func TestMockHypervisorInit(t *testing.T) {
 	}
 
 // right config
-err=m.init(pod)
-iferr!=nil {
+iferr:=m.init(pod); err!=nil {
 t.Fatal(err)
 	}
 }
@@ -59,42 +56,39 @@ func TestMockHypervisorCreatePod(t *testing.T) {
 
 config:=PodConfig{}
 
-err:=m.createPod(config)
-iferr!=nil {
+iferr:=m.createPod(config); err!=nil {
 t.Fatal(err)
 	}
 }
 
 funcTestMockHypervisorStartPod(t*testing.T) {
 varm*mockHypervisor
 
-startCh:=make(chanstruct{})
-stopCh:=make(chanstruct{})
+iferr:=m.startPod(); err!=nil {
+t.Fatal(err)
+	}
+}
 
-gom.startPod(startCh, stopCh)
+funcTestMockHypervisorWaitPod(t*testing.T) {
+varm*mockHypervisor
 
-select {
-case<-startCh:
-break
-case<-time.After(time.Second):
-t.Fatal("Timeout waiting for start notification")
+iferr:=m.waitPod(0); err!=nil {
+t.Fatal(err)
 	}
 }
 
 funcTestMockHypervisorStopPod(t*testing.T) {
 varm*mockHypervisor
 
-err:=m.stopPod()
-iferr!=nil {
+iferr:=m.stopPod(); err!=nil {
 t.Fatal(err)
 	}
 }
 
 funcTestMockHypervisorAddDevice(t*testing.T) {
 varm*mockHypervisor
 
-err:=m.addDevice(nil, imgDev)
-iferr!=nil {
+iferr:=m.addDevice(nil, imgDev); err!=nil {
 t.Fatal(err)
 	}
 }

pod.go

@@ -23,7 +23,6 @@ import (
 "strings"
 "sync"
 "syscall"
-"time"
 
 "github.com/sirupsen/logrus"
 )
@@ -39,6 +38,10 @@ const controlSocket = "ctrl.sock"
 // to understand if the VM is still alive or not.
 constmonitorSocket="monitor.sock"
 
+// vmStartTimeout represents the time in seconds a pod can wait before
+// to consider the VM starting operation failed.
+constvmStartTimeout=10
+
 // stateString is a string representing a pod state.
 typestateStringstring
 
@@ -748,34 +751,13 @@ func (p *Pod) startSetState() error {
 returnnil
 }
 
-// startVM starts the VM, ensuring it is started before it returns or issuing
-// an error in case of timeout. Then it connects to the agent inside the VM.
+// startVM starts the VM.
 func (p*Pod) startVM(netNsPathstring) error {
-vmStartedCh:=make(chanstruct{})
-vmStoppedCh:=make(chanstruct{})
-consttimeout=time.Duration(10) *time.Second
-
-l:=p.Logger()
-l.Info("Starting VM")
-
-gofunc() {
-p.network.run(netNsPath, func() error {
-err:=p.hypervisor.startPod(vmStartedCh, vmStoppedCh)
-returnerr
- })
-	}()
-
-// Wait for the pod started notification
-select {
-case<-vmStartedCh:
-break
-case<-time.After(timeout):
-returnfmt.Errorf("Did not receive the pod started notification (timeout %ds)", timeout)
-	}
-
-l.Info("VM started")
+p.Logger().Info("Starting VM")
 
-returnnil
+returnp.network.run(netNsPath, func() error {
+returnp.hypervisor.startPod()
+	})
 }
 
 // startShims registers all containers to the proxy and starts one
@@ -835,6 +817,14 @@ func (p *Pod) start() error {
 returnerr
 	}
 
+l:=p.Logger()
+
+iferr:=p.hypervisor.waitPod(vmStartTimeout); err!=nil {
+returnerr
+	}
+
+l.Info("VM started")
+
 if_, _, err:=p.proxy.connect(*p, false); err!=nil {
 returnerr
 	}
@@ -855,7 +845,7 @@ func (p *Pod) start() error {
  }
 	}
 
-p.Logger().Info("started")
+l.Info("started")
 
 returnnil
 }

qemu.go

@@ -573,40 +573,6 @@ func (q *qemu) init(pod *Pod) error {
 returnnil
 }
 
-func (q*qemu) qmpMonitor(connectedChchanstruct{}) {
-deferfunc(qemu*qemu) {
-ifq.qmpMonitorCh.qmp!=nil {
-q.qmpMonitorCh.qmp.Shutdown()
- }
-
-q.qmpMonitorCh.wg.Done()
-	}(q)
-
-cfg:= ciaoQemu.QMPConfig{Logger: newQMPLogger()}
-qmp, ver, err:=ciaoQemu.QMPStart(q.qmpMonitorCh.ctx, q.qmpMonitorCh.path, cfg, q.qmpMonitorCh.disconnectCh)
-iferr!=nil {
-q.Logger().WithError(err).Error("Failed to connect to QEMU instance")
-return
-	}
-
-q.qmpMonitorCh.qmp=qmp
-
-q.Logger().WithFields(logrus.Fields{
-"qmp-major-version": ver.Major,
-"qmp-minor-version": ver.Minor,
-"qmp-micro-version": ver.Micro,
-"qmp-capabilities": strings.Join(ver.Capabilities, ","),
-	}).Infof("QMP details")
-
-err=q.qmpMonitorCh.qmp.ExecuteQMPCapabilities(q.qmpMonitorCh.ctx)
-iferr!=nil {
-q.Logger().WithError(err).Error(qmpCapErrMsg)
-return
-	}
-
-close(connectedCh)
-}
-
 func (q*qemu) setCPUResources(podConfigPodConfig) ciaoQemu.SMP {
 vcpus:=q.config.DefaultVCPUs
 ifpodConfig.VMConfig.VCPUs>0 {
@@ -775,16 +741,61 @@ func (q *qemu) createPod(podConfig PodConfig) error {
 }
 
 // startPod will start the Pod's VM.
-func (q*qemu) startPod(startCh, stopChchanstruct{}) error {
+func (q*qemu) startPod() error {
 strErr, err:=ciaoQemu.LaunchQemu(q.qemuConfig, newQMPLogger())
 iferr!=nil {
 returnfmt.Errorf("%s", strErr)
 	}
 
-// Start the QMP monitoring thread
-q.qmpMonitorCh.disconnectCh=stopCh
-q.qmpMonitorCh.wg.Add(1)
-q.qmpMonitor(startCh)
+returnnil
+}
+
+// waitPod will wait for the Pod's VM to be up and running.
+func (q*qemu) waitPod(timeoutint) error {
+deferfunc(qemu*qemu) {
+ifq.qmpMonitorCh.qmp!=nil {
+q.qmpMonitorCh.qmp.Shutdown()
+ }
+	}(q)
+
+iftimeout<0 {
+returnfmt.Errorf("Invalid timeout %ds", timeout)
+	}
+
+disconnectCh:=make(chanstruct{})
+cfg:= ciaoQemu.QMPConfig{Logger: newQMPLogger()}
+
+varqmp*ciaoQemu.QMP
+varver*ciaoQemu.QMPVersion
+varerrerror
+
+timeStart:=time.Now()
+for {
+qmp, ver, err=ciaoQemu.QMPStart(q.qmpMonitorCh.ctx, q.qmpMonitorCh.path, cfg, disconnectCh)
+iferr==nil {
+break
+ }
+
+ifint(time.Now().Sub(timeStart).Seconds()) >timeout {
+returnfmt.Errorf("Failed to connect to QEMU instance (timeout %ds): %v", timeout, err)
+ }
+
+time.Sleep(time.Duration(50) *time.Millisecond)
+	}
+
+q.qmpMonitorCh.qmp=qmp
+
+q.Logger().WithFields(logrus.Fields{
+"qmp-major-version": ver.Major,
+"qmp-minor-version": ver.Minor,
+"qmp-micro-version": ver.Micro,
+"qmp-capabilities": strings.Join(ver.Capabilities, ","),
+	}).Infof("QMP details")
+
+iferr=q.qmpMonitorCh.qmp.ExecuteQMPCapabilities(q.qmpMonitorCh.ctx); err!=nil {
+q.Logger().WithError(err).Error(qmpCapErrMsg)
+returnerr
+	}
 
 returnnil
 }