// Cfsetospeed sets the output baud rate stored in the termios structure.
493895
func Cfsetospeed(attr *syscall.Termios, speed uintptr) error {
	solTermios := tiosToUnix(attr)
	_, err := C.cfsetospeed((*C.termios_t)(unsafe.Pointer(solTermios)), C.speed_t(speed))
	return err
}
819028
func (u *Units) GetSpeed() (speed cunits.Bits) {
	return cunits.ImportInByte(float64(u.SpeedBytes))
}
281565
func (u *Ugen) Cpsoct() Input {
	return unaryOpCpsoct(u.Rate, u, u.NumOutputs)
}
919064
func (d *Domain) BlockJobSetSpeed(disk string, bandwidth uint64, flags DomainBlockJobSetSpeedFlags) error {
	cdisk := C.CString(disk)
	defer C.free(unsafe.Pointer(cdisk))
	var err C.virError
	ret := C.virDomainBlockJobSetSpeedWrapper(d.ptr, cdisk, C.ulong(bandwidth), C.uint(flags), &err)
	if ret == -1 {
		return makeError(&err)
	}
	return nil
}
808027
func (s *AacSettings) SetRateControlMode(v string) *AacSettings {
	s.RateControlMode = &v
	return s
}
159585
func (s *OutputSettings) SetMsSmoothOutputSettings(v *MsSmoothOutputSettings) *OutputSettings {
	s.MsSmoothOutputSettings = v
	return s
}
1370010
func (p *Peer) ConvertDownloadSpeed() (speed cunits.Bits) {
	return cunits.ImportInByte(float64(p.RateToClient))
}
1351099
func (m *MotorDriver) Speed(value byte) (err error) {
	if writer, ok := m.connection.(PwmWriter); ok {
		m.CurrentMode = "analog"
		m.CurrentSpeed = value
		return writer.PwmWrite(m.SpeedPin, value)
	}
	return ErrPwmWriteUnsupported
}
265839
func (t *Term) SetSpeed(baud int) error {
	return t.SetOption(Speed(baud))
}
837734
func controlRate(done <-chan struct{}, ops <-chan map[string]interface{},
	controller ratecontroller.Controller) <-chan map[string]interface{} {
	// The choice of 20 for the maximum number of operations to apply at once is fairly arbitrary
	c := make(chan map[string]interface{}, 20)

	go func() {
		defer close(c)
		for op := range ops {
			if op["ns"] == "" {
				continue
			}
			time.Sleep(controller.WaitTime(op))
			select {
			case c <- op:
			case <-done:
			}
		}
	}()
	return c
}
1315733
func (s *VideoMetadata) SetFrameRate(v float64) *VideoMetadata {
	s.FrameRate = &v
	return s
}
196013
func (soc *Socket) SetRate(value int) error {
	return soc.setInt(C.ZMQ_RATE, value)
}
524492
func (s *StepperDriver) SetSpeed(rpm uint) error {
	if rpm <= 0 {
		return errors.New("RPM cannot be a zero or negative value")
	}

	m := s.GetMaxSpeed()
	if rpm > m {
		rpm = m
	}

	s.speed = rpm
	return nil
}
1285369
func (s *Client) TimingDuration(stat string, delta time.Duration, rate float32) error {
	if !s.includeStat(rate) {
		return nil
	}

	ms := float64(delta) / float64(time.Millisecond)
	return s.submit(stat, "", ms, "|ms", rate)
}
52595
func FIPSModeSet(mode bool) error {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	var r C.int
	if mode {
		r = C.X_FIPS_mode_set(1)
	} else {
		r = C.X_FIPS_mode_set(0)
	}
	if r != 1 {
		return errorFromErrorQueue()
	}
	return nil
}
930553
func (c *client) SetMaxRate(ctx context.Context, rate int64) ([]string, error) {
	request := &throttlerdatapb.SetMaxRateRequest{
		Rate: rate,
	}

	response, err := c.gRPCClient.SetMaxRate(ctx, request)
	if err != nil {
		return nil, vterrors.FromGRPC(err)
	}
	return response.Names, nil
}
692086
func (c *Emulation) SetCPUThrottlingRate(rate float64) (*gcdmessage.ChromeResponse, error) {
	var v EmulationSetCPUThrottlingRateParams
	v.Rate = rate
	return c.SetCPUThrottlingRateWithParams(&v)
}