func (this *Parallel) RunOnce(context *Context, parent value.Value) {
this.once.Do(func() {
defer context.Recover() // Recover from any panic
defer close(this.itemChannel) // Broadcast that I have stopped
defer this.notify() // Notify that I have stopped
n := util.MinInt(this.plan.MaxParallelism(), context.MaxParallelism())
children := _PARALLEL_POOL.Get()[0:n]
defer _PARALLEL_POOL.Put(children)
for i := 1; i < n; i++ {
children[i] = this.child.Copy()
go this.runChild(children[i], context, parent)
}
children[0] = this.child
go this.runChild(children[0], context, parent)
for n > 0 {
select {
case <-this.childChannel: // Never closed
// Wait for all children
n--
case <-this.stopChannel: // Never closed
this.notifyStop()
notifyChildren(children...)
}
}
})
}
// Parallel
func (this *builder) VisitParallel(plan *plan.Parallel) (interface{}, error) {
child, err := plan.Child().Accept(this)
if err != nil {
return nil, err
}
maxParallelism := util.MinInt(plan.MaxParallelism(), this.context.MaxParallelism())
if maxParallelism == 1 {
return child, nil
} else {
return NewParallel(plan, child.(Operator)), nil
}
}
func main() {
HideConsole(true)
defer HideConsole(false)
// useful for getting list of go-routines
go go_http.ListenAndServe("localhost:6060", nil)
flag.Parse()
if *LOGGER != "" {
logger, _ := log_resolver.NewLogger(*LOGGER)
if logger == nil {
fmt.Printf("Invalid logger: %s\n", *LOGGER)
os.Exit(1)
}
logging.SetLogger(logger)
}
if *DEBUG {
logging.SetLevel(logging.DEBUG)
} else {
level := logging.INFO
if *LOG_LEVEL != "" {
lvl, ok := logging.ParseLevel(*LOG_LEVEL)
if ok {
level = lvl
}
}
logging.SetLevel(level)
}
datastore, err := resolver.NewDatastore(*DATASTORE)
if err != nil {
logging.Errorp(err.Error())
os.Exit(1)
}
datastore_package.SetDatastore(datastore)
configstore, err := config_resolver.NewConfigstore(*CONFIGSTORE)
if err != nil {
logging.Errorp("Could not connect to configstore",
logging.Pair{"error", err},
)
}
acctstore, err := acct_resolver.NewAcctstore(*ACCTSTORE)
if err != nil {
logging.Errorp("Could not connect to acctstore",
logging.Pair{"error", err},
)
} else {
// Create the metrics we are interested in
accounting.RegisterMetrics(acctstore)
// Make metrics available
acctstore.MetricReporter().Start(1, 1)
}
channel := make(server.RequestChannel, *REQUEST_CAP)
plusChannel := make(server.RequestChannel, *REQUEST_CAP)
sys, err := system.NewDatastore(datastore)
if err != nil {
logging.Errorp(err.Error())
os.Exit(1)
}
server, err := server.NewServer(datastore, sys, configstore, acctstore, *NAMESPACE,
*READONLY, channel, plusChannel, *SERVICERS, *PLUS_SERVICERS,
*MAX_PARALLELISM, *TIMEOUT, *SIGNATURE, *METRICS, *ENTERPRISE)
if err != nil {
logging.Errorp(err.Error())
os.Exit(1)
}
datastore_package.SetSystemstore(server.Systemstore())
server.SetCpuProfile(*CPU_PROFILE)
server.SetKeepAlive(*KEEP_ALIVE_LENGTH)
server.SetMemProfile(*MEM_PROFILE)
server.SetPipelineCap(*PIPELINE_CAP)
server.SetPipelineBatch(*PIPELINE_BATCH)
server.SetRequestSizeCap(*REQUEST_SIZE_CAP)
server.SetScanCap(*SCAN_CAP)
if server.Enterprise() && os.Getenv("GOMAXPROCS") == "" {
runtime.GOMAXPROCS(runtime.NumCPU())
}
if !server.Enterprise() {
var numCPU int
if os.Getenv("GOMAXPROCS") == "" {
numCPU = runtime.NumCPU()
} else {
numCPU = runtime.GOMAXPROCS(0)
}
// Use at most 4 cpus in non-enterprise mode
runtime.GOMAXPROCS(util.MinInt(numCPU, 4))
}
go server.Serve()
go server.PlusServe()
logging.Infop("cbq-engine started",
logging.Pair{"version", util.VERSION},
logging.Pair{"datastore", *DATASTORE},
logging.Pair{"max-concurrency", runtime.GOMAXPROCS(0)},
logging.Pair{"loglevel", logging.LogLevel().String()},
logging.Pair{"servicers", server.Servicers()},
logging.Pair{"plus-servicers", server.PlusServicers()},
logging.Pair{"pipeline-cap", server.PipelineCap()},
logging.Pair{"pipeline-batch", *PIPELINE_BATCH},
logging.Pair{"request-cap", *REQUEST_CAP},
logging.Pair{"request-size-cap", server.RequestSizeCap()},
logging.Pair{"timeout", server.Timeout()},
)
// Create http endpoint
endpoint := http.NewServiceEndpoint(server, *STATIC_PATH, *METRICS,
*HTTP_ADDR, *HTTPS_ADDR, *CERT_FILE, *KEY_FILE)
er := endpoint.Listen()
if er != nil {
logging.Errorp("cbq-engine exiting with error",
logging.Pair{"error", er},
logging.Pair{"HTTP_ADDR", *HTTP_ADDR},
)
os.Exit(1)
}
if server.Enterprise() && *CERT_FILE != "" && *KEY_FILE != "" {
er := endpoint.ListenTLS()
if er != nil {
logging.Errorp("cbq-engine exiting with error",
logging.Pair{"error", er},
logging.Pair{"HTTPS_ADDR", *HTTPS_ADDR},
)
os.Exit(1)
}
}
signalCatcher(server, endpoint)
}