func Start(opts ...Option) error {
	c := newConfig(opts...)
	if c.MinimumReadMemStatsInterval < 0 {
		c.MinimumReadMemStatsInterval = DefaultMinimumReadMemStatsInterval
	}
	if c.MeterProvider == nil {
		c.MeterProvider = global.GetMeterProvider()
	}
	r := &runtime{
		meter: c.MeterProvider.Meter(
			"go.opentelemetry.io/contrib/instrumentation/runtime",
			metric.WithInstrumentationVersion(SemVersion()),
		),
		config: c,
	}
	return r.register()
}
Start initializes reporting of runtime metrics using the supplied config.
package runtime  
import (
	"context"
	goruntime "runtime"
	"sync"
	"time"
	"go.opentelemetry.io/otel/metric"
	"go.opentelemetry.io/otel/metric/global"
	"go.opentelemetry.io/otel/metric/unit"
)
type runtime struct {
	config config
	meter  metric.Meter
}
type config struct {
	MinimumReadMemStatsInterval time.Duration
	MeterProvider metric.MeterProvider
}
type Option interface {
	apply(*config)
}
const DefaultMinimumReadMemStatsInterval time.Duration = 15 * time.Second
func WithMinimumReadMemStatsInterval(d time.Duration) Option {
	return minimumReadMemStatsIntervalOption(d)
}
type minimumReadMemStatsIntervalOption time.Duration
func (o minimumReadMemStatsIntervalOption) apply(c *config) {
	if o >= 0 {
		c.MinimumReadMemStatsInterval = time.Duration(o)
	}
}
func WithMeterProvider(provider metric.MeterProvider) Option {
	return metricProviderOption{provider}
}
type metricProviderOption struct{ metric.MeterProvider }
func (o metricProviderOption) apply(c *config) {
	if o.MeterProvider != nil {
		c.MeterProvider = o.MeterProvider
	}
}
func newConfig(opts ...Option) config {
	c := config{
		MeterProvider:               global.GetMeterProvider(),
		MinimumReadMemStatsInterval: DefaultMinimumReadMemStatsInterval,
	}
	for _, opt := range opts {
		opt.apply(&c)
	}
	return c
}