侵权投诉

golang的调度模型-GPM 模型的源码结构

Linux爱好者 2021-07-06 11:55 次阅读

【导读】GMP 模型是让 go 语言轻量快速高效的重要调度模型,本文从 GMP 源码出发直观地解析了这一模型。

这篇文章就来看看 golang 的调度模型-GPM 模型的源码结构。

Go 版本:go1.13.9

M 结构体

M 结构体是 OS 线程的一个抽象,主要负责结合 P 运行 G。它里面有很多字段,差不多有 60 个字段,我们看看里面主要的字段意思。/src/runtime/runtime2.go

Copytype m struct {

// 系统管理的一个 g,执行调度代码时使用的。比如执行用户的 goroutine 时,就需要把把用户

// 的栈信息换到内核线程的栈,以便能够执行用户 goroutine

g0 *g // goroutine with scheduling stack

morebuf gobuf // gobuf arg to morestack

divmod uint32 // div/mod denominator for arm - known to liblink

// Fields not known to debuggers.

procid uint64 // for debuggers, but offset not hard-coded

//处理 signal 的 g

gsignal *g // signal-handling g

goSigStack gsignalStack // Go-allocated signal handling stack

sigmask sigset // storage for saved signal mask

//线程的本地存储 TLS,这里就是为什么 OS 线程能运行 M 关键地方

tls [6]uintptr // thread-local storage (for x86 extern register)

//go 关键字运行的函数

mstartfn func()

//当前运行的用户 goroutine 的 g 结构体对象

curg *g // current running goroutine

caughtsig guintptr // goroutine running during fatal signal

//当前工作线程绑定的 P,如果没有就为 nil

p puintptr // attached p for executing go code (nil if not executing go code)

//暂存与当前 M 潜在关联的 P

nextp puintptr

//M 之前调用的 P

oldp puintptr // the p that was attached before executing a syscall

id int64

mallocing int32

throwing int32

//当前 M 是否关闭抢占式调度

preemptoff string // if != “”, keep curg running on this m

locks int32

dying int32

profilehz int32

//M 的自旋状态,为 true 时 M 处于自旋状态,正在从其他线程偷 G; 为 false,休眠状态

spinning bool // m is out of work and is actively looking for work

blocked bool // m is blocked on a note

newSigstack bool // minit on C thread called sigaltstack

printlock int8

incgo bool // m is executing a cgo call

freeWait uint32 // if == 0, safe to free g0 and delete m (atomic)

fastrand [2]uint32

needextram bool

traceback uint8

ncgocall uint64 // number of cgo calls in total

ncgo int32 // number of cgo calls currently in progress

cgoCallersUse uint32 // if non-zero, cgoCallers in use temporarily

cgoCallers *cgoCallers // cgo traceback if crashing in cgo call

//没有 goroutine 运行时,工作线程睡眠

//通过这个来唤醒工作线程

park note // 休眠锁

//记录所有工作线程的链表

alllink *m // on allm

schedlink muintptr

//当前线程内存分配的本地缓存

mcache *mcache

//当前 M 锁定的 G,

lockedg guintptr

createstack [32]uintptr // stack that created this thread.

lockedExt uint32 // tracking for external LockOSThread

lockedInt uint32 // tracking for internal lockOSThread

nextwaitm muintptr // next m waiting for lock

waitunlockf func(*g, unsafe.Pointer) bool

waitlock unsafe.Pointer

waittraceev byte

waittraceskip int

startingtrace bool

syscalltick uint32

//操作系统线程 id

thread uintptr // thread handle

freelink *m // on sched.freem

// these are here because they are too large to be on the stack

// of low-level NOSPLIT functions.

libcall libcall

libcallpc uintptr // for cpu profiler

libcallsp uintptr

libcallg guintptr

syscall libcall // stores syscall parameters on windows

vdsoSP uintptr // SP for traceback while in VDSO call (0 if not in call)

vdsoPC uintptr // PC for traceback while in VDSO call

dlogPerM

mOS

}

看看几个比较重要的字段:g0:用于执行调度器的 g0gsignal:用于信号处理tls:线程本地存储的 tlsp:goroutine 绑定的本地资源

P 结构体

一个 M 要运行,必须绑定 P 才能运行 goroutine,M 阻塞时,P 会被传给其他 M。

/src/runtime/runtime2.go

Copytype p struct {

//allp 中的索引

id int32

//p 的状态

status uint32 // one of pidle/prunning/。。.

link puintptr

schedtick uint32 // incremented on every scheduler call-》每次 scheduler 调用+1

syscalltick uint32 // incremented on every system call-》每次系统调用+1

sysmontick sysmontick // last tick observed by sysmon

//指向绑定的 m,如果 p 是 idle 的话,那这个指针是 nil

m muintptr // back-link to associated m (nil if idle)

mcache *mcache

raceprocctx uintptr

//不同大小可用 defer 结构池

deferpool [5][]*_defer // pool of available defer structs of different sizes (see panic.go)

deferpoolbuf [5][32]*_defer

// Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.

goidcache uint64

goidcacheend uint64

//本地运行队列,可以无锁访问

// Queue of runnable goroutines. Accessed without lock.

runqhead uint32 //队列头

runqtail uint32 //队列尾

//数组实现的循环队列

runq [256]guintptr

// runnext, if non-nil, is a runnable G that was ready‘d by

// the current G and should be run next instead of what’s in

// runq if there‘s time remaining in the running G’s time

// slice. It will inherit the time left in the current time

// slice. If a set of goroutines is locked in a

// communicate-and-wait pattern, this schedules that set as a

// unit and eliminates the (potentially large) scheduling

// latency that otherwise arises from adding the ready‘d

// goroutines to the end of the run queue.

// runnext 非空时,代表的是一个 runnable 状态的 G,

//这个 G 被 当前 G 修改为 ready 状态,相比 runq 中的 G 有更高的优先级。

//如果当前 G 还有剩余的可用时间,那么就应该运行这个 G

//运行之后,该 G 会继承当前 G 的剩余时间

runnext guintptr

// Available G’s (status == Gdead)

//空闲的 g

gFree struct {

gList

n int32

}

sudogcache []*sudog

sudogbuf [128]*sudog

tracebuf traceBufPtr

// traceSweep indicates the sweep events should be traced.

// This is used to defer the sweep start event until a span

// has actually been swept.

traceSweep bool

// traceSwept and traceReclaimed track the number of bytes

// swept and reclaimed by sweeping in the current sweep loop.

traceSwept, traceReclaimed uintptr

palloc persistentAlloc // per-P to avoid mutex

_ uint32 // Alignment for atomic fields below

// Per-P GC state

gcAssistTime int64 // Nanoseconds in assistAlloc

gcFractionalMarkTime int64 // Nanoseconds in fractional mark worker (atomic)

gcBgMarkWorker guintptr // (atomic)

gcMarkWorkerMode gcMarkWorkerMode

// gcMarkWorkerStartTime is the nanotime() at which this mark

// worker started.

gcMarkWorkerStartTime int64

// gcw is this P‘s GC work buffer cache. The work buffer is

// filled by write barriers, drained by mutator assists, and

// disposed on certain GC state transitions.

gcw gcWork

// wbBuf is this P’s GC write barrier buffer.

//

// TODO: Consider caching this in the running G.

wbBuf wbBuf

runSafePointFn uint32 // if 1, run sched.safePointFn at next safe point

pad cpu.CacheLinePad

}

其他的一些字段就是 gc,trace,debug 信息

G 结构体

G 就是 goroutine。主要保存 goroutine 的所有信息以及栈信息,gobuf 结构体:cpu 里的寄存器信息,以便在轮到本 goroutine 执行时,知道从哪里开始执行。

/src/runtime/runtime2.go

Copytype stack struct {

lo uintptr //栈顶,指向内存低地址

hi uintptr //栈底,指向内存搞地址

}

type g struct {

// Stack parameters.

// stack describes the actual stack memory: [stack.lo, stack.hi)。

// stackguard0 is the stack pointer compared in the Go stack growth prologue.

// It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.

// stackguard1 is the stack pointer compared in the C stack growth prologue.

// It is stack.lo+StackGuard on g0 and gsignal stacks.

// It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash)。

// 记录该 goroutine 使用的栈

stack stack // offset known to runtime/cgo

//下面两个成员用于栈溢出检查,实现栈的自动伸缩,抢占调度也会用到 stackguard0

stackguard0 uintptr // offset known to liblink

stackguard1 uintptr // offset known to liblink

_panic *_panic // innermost panic - offset known to liblink

_defer *_defer // innermost defer

// 此 goroutine 正在被哪个工作线程执行

m *m // current m; offset known to arm liblink

//这个字段跟调度切换有关,G 切换时用来保存上下文,保存什么,看下面 gobuf 结构体

sched gobuf

syscallsp uintptr // if status==Gsyscall, syscallsp = sched.sp to use during gc

syscallpc uintptr // if status==Gsyscall, syscallpc = sched.pc to use during gc

stktopsp uintptr // expected sp at top of stack, to check in traceback

param unsafe.Pointer // passed parameter on wakeup,wakeup 唤醒时传递的参数

// 状态 Gidle,Grunnable,Grunning,Gsyscall,Gwaiting,Gdead

atomicstatus uint32

stackLock uint32 // sigprof/scang lock; TODO: fold in to atomicstatus

goid int64

//schedlink 字段指向全局运行队列中的下一个 g,

//所有位于全局运行队列中的 g 形成一个链表

schedlink guintptr

waitsince int64 // approx time when the g become blocked

waitreason waitReason // if status==Gwaiting,g 被阻塞的原因

//抢占信号,stackguard0 = stackpreempt,如果需要抢占调度,设置 preempt 为 true

preempt bool // preemption signal, duplicates stackguard0 = stackpreempt

paniconfault bool // panic (instead of crash) on unexpected fault address

preemptscan bool // preempted g does scan for gc

gcscandone bool // g has scanned stack; protected by _Gscan bit in status

gcscanvalid bool // false at start of gc cycle, true if G has not run since last scan; TODO: remove?

throwsplit bool // must not split stack

raceignore int8 // ignore race detection events

sysblocktraced bool // StartTrace has emitted EvGoInSyscall about this goroutine

sysexitticks int64 // cputicks when syscall has returned (for tracing)

traceseq uint64 // trace event sequencer

tracelastp puintptr // last P emitted an event for this goroutine

// 如果调用了 LockOsThread,那么这个 g 会绑定到某个 m 上

lockedm muintptr

sig uint32

writebuf []byte

sigcode0 uintptr

sigcode1 uintptr

sigpc uintptr

// 创建这个 goroutine 的 go 表达式的 pc

gopc uintptr // pc of go statement that created this goroutine

ancestors *[]ancestorInfo // ancestor information goroutine(s) that created this goroutine (only used if debug.tracebackancestors)

startpc uintptr // pc of goroutine function

racectx uintptr

waiting *sudog // sudog structures this g is waiting on (that have a valid elem ptr); in lock order

cgoCtxt []uintptr // cgo traceback context

labels unsafe.Pointer // profiler labels

timer *timer // cached timer for time.Sleep, 为 time.Sleep 缓存的计时

selectDone uint32 // are we participating in a select and did someone win the race?

// Per-G GC state

// gcAssistBytes is this G‘s GC assist credit in terms of

// bytes allocated. If this is positive, then the G has credit

// to allocate gcAssistBytes bytes without assisting. If this

// is negative, then the G must correct this by performing

// scan work. We track this in bytes to make it fast to update

// and check for debt in the malloc hot path. The assist ratio

// determines how this corresponds to scan work debt.

gcAssistBytes int64

}

gobuf

gobuf 结构体用于保存 goroutine 的调度信息,主要包括 CPU 的几个寄存器的值。

/src/runtime/runtime2.go

Copytype gobuf struct {

// The offsets of sp, pc, and g are known to (hard-coded in) libmach.

//

// ctxt is unusual with respect to GC: it may be a

// heap-allocated funcval, so GC needs to track it, but it

// needs to be set and cleared from assembly, where it’s

// difficult to have write barriers. However, ctxt is really a

// saved, live register, and we only ever exchange it between

// the real register and the gobuf. Hence, we treat it as a

// root during stack scanning, which means assembly that saves

// and restores it doesn‘t need write barriers. It’s still

// typed as a pointer so that any other writes from Go get

// write barriers.

sp uintptr // 保存 CPU 的 rsp 寄存器的值

pc uintptr // 保存 CPU 的 rip 寄存器的值

g guintptr // 记录当前这个 gobuf 对象属于哪个 goroutine

ctxt unsafe.Pointer

//保存系统调用的返回值,因为从系统调用返回之后如果 p 被其它工作线程抢占,

//则这个 goroutine 会被放入全局运行队列被其它工作线程调度,其它线程需要知道系统调用的返回值。

ret sys.Uintreg // 保存系统调用的返回值

lr uintptr

//保存 CPU 的 rip 寄存器的值

bp uintptr // for GOEXPERIMENT=framepointer

}

调度器 sched 结构

所有的 gorouteine 都是被调度器调度运行,调度器持有全局资源

sched

/src/runtime/runtime2.go

Copytype schedt struct {

// accessed atomically. keep at top to ensure alignment on 32-bit systems.

// 需以原子访问访问。

// 保持在 struct 顶部,以使其在 32 位系统上可以对齐

goidgen uint64

lastpoll uint64

lock mutex

// When increasing nmidle, nmidlelocked, nmsys, or nmfreed, be

// sure to call checkdead()。

//由空闲的工作线程组成的链表

midle muintptr // idle m‘s waiting for work

//空闲的工作线程的数量

nmidle int32 // number of idle m’s waiting for work

//空闲的且被 lock 的 m 计数

nmidlelocked int32 // number of locked m‘s waiting for work

//已经创建的多个 m,下一个 m id

mnext int64 // number of m’s that have been created and next M ID

//被允许创建的最大 m 线程数量

maxmcount int32 // maximum number of m‘s allowed (or die)

nmsys int32 // number of system m’s not counted for deadlock

//累积空闲的 m 数量

nmfreed int64 // cumulative number of freed m‘s

//系统 goroutine 的数量,自动更新

ngsys uint32 // number of system goroutines; updated atomically

//由空闲的 p 结构体对象组成的链表

pidle puintptr // idle p’s

//空闲的 p 结构体对象的数量

npidle uint32

nmspinning uint32 // See “Worker thread parking/unparking” comment in proc.go.

// Global runnable queue.

//全局运行队列 G 队列

runq gQueue //这个结构体在 proc.go 里

//元素数量

runqsize int32

// disable controls selective disabling of the scheduler.

//

// Use schedEnableUser to control this.

//

// disable is protected by sched.lock.

disable struct {

// user disables scheduling of user goroutines.

user bool

runnable gQueue // pending runnable Gs

n int32 // length of runnable

}

// Global cache of dead G‘s. 有效 dead G 全局缓存

gFree struct {

lock mutex

stack gList // Gs with stacks

noStack gList // Gs without stacks

n int32

}

// Central cache of sudog structs. dusog 结构的集中缓存

sudoglock mutex

sudogcache *sudog

// Central pool of available defer structs of different sizes. 不同大小有效的 defer 结构的池

deferlock mutex

deferpool [5]*_defer

// freem is the list of m’s waiting to be freed when their

// m.exited is set. Linked through m.freelink.

freem *m

gcwaiting uint32 // gc is waiting to run

stopwait int32

stopnote note

sysmonwait uint32

sysmonnote note

// safepointFn should be called on each P at the next GC

// safepoint if p.runSafePointFn is set.

safePointFn func(*p)

safePointWait int32

safePointNote note

profilehz int32 // cpu profiling rate

procresizetime int64 // nanotime() of last change to gomaxprocs

totaltime int64 // ∫gomaxprocs dt up to procresizetime

}

gQueue

/src/runtime/proc.go

Copytype gQueue struct {

head guintptr //队列头

tail guintptr //队列尾

}

一些重要全局变量

/src/runtime/proc.go

Copym0 m //代表主线程

g0 g //m0 绑定的 g0,也就是 M 结构体中 m0.g0=&g0

allgs []*g //保存所有的 g

/src/runtime/runtime2.go

Copyallm *m //所有的 m 构成的一个链表,包括上面的 m0

allp []*p //保存所有的 p, len(allp) == gomaxprocs

sched schedt //调度器的结构体,保存了调度器的各种信息

ncpu int32 //系统 cpu 核的数量,程序启动时由 runtime 初始化

gomaxprocs int32 //p 的最大数量,默认等于 ncpu,可以通过 GOMAXPROCS 修改

在程序初始化时,这些变量都会被初始化为 0 值,指针会被初始化为 nil 指针,切片初始化为 nil 切片,int 被初始化为数字 0,结构体的所有成员变量按其本类型初始化为其类型的 0 值。

调度器初始化

调度器初始化有一个主要的函数 schedinit(), 这个函数在 /src/runtime/proc.go 文件中。函数开头还把初始化的顺序给列出来了:

// The bootstrap sequence is://// call osinit// call schedinit// make & queue new G// call runtime·mstart//// The new G calls runtime·main.

Copyfunc schedinit() {

// raceinit must be the first call to race detector.

// In particular, it must be done before mallocinit below calls racemapshadow.

_g_ := getg() //getg() 在 src/runtime/stubs.go 中声明,真正的代码由编译器生成

if raceenabled {

_g_.racectx, raceprocctx0 = raceinit()

}

//设置最大 M 的数量

sched.maxmcount = 10000

tracebackinit()

moduledataverify()

//初始化栈空间常用管理链表

stackinit()

mallocinit()

//初始化当前 m

mcommoninit(_g_.m)

cpuinit() // must run before alginit

alginit() // maps must not be used before this call

modulesinit() // provides activeModules

typelinksinit() // uses maps, activeModules

itabsinit() // uses activeModules

msigsave(_g_.m)

initSigmask = _g_.m.sigmask

goargs()

goenvs()

parsedebugvars()

gcinit()

sched.lastpoll = uint64(nanotime())

// 把 p 数量从 1 调整到默认的 CPU Core 数量

procs := ncpu

if n, ok := atoi32(gogetenv(“GOMAXPROCS”)); ok && n 》 0 {

procs = n

}

//调整 P 数量

//这里的 P 都是新建的,所以不返回有本地任务的 p

if procresize(procs) != nil {

throw(“unknown runnable goroutine during bootstrap”)

}

// For cgocheck 》 1, we turn on the write barrier at all times

// and check all pointer writes. We can‘t do this until after

// procresize because the write barrier needs a P.

if debug.cgocheck 》 1 {

writeBarrier.cgo = true

writeBarrier.enabled = true

for _, p := range allp {

p.wbBuf.reset()

}

}

if buildVersion == “” {

// Condition should never trigger. This code just serves

// to ensure runtime·buildVersion is kept in the resulting binary.

buildVersion = “unknown”

}

if len(modinfo) == 1 {

// Condition should never trigger. This code just serves

// to ensure runtime·modinfo is kept in the resulting binary.

modinfo = “”

}

}

开头的这个函数 getg(),跳转到了 func getg() *g ,定义这么一个形式,什么意思?函数首先调用 getg() 函数获取当前正在运行的 g,getg() 在 src/runtime/stubs.go 中声明,真正的代码由编译器生成。

Copy// getg returns the pointer to the current g.// The compiler rewrites calls to this function into instructions// that fetch the g directly (from TLS or from the dedicated register).func getg() *g

注释里也说了,getg 返回当前正在运行的 goroutine 的指针,它会从 tls 里取出 tls[0],也就是当前运行的 goroutine 的地址。编译器插入类似下面的代码:

Copyget_tls(CX)

MOVQ g(CX), BX; // BX 存器里面现在放的是当前 g 结构体对象的地址

原来是这么个意思。

调度器初始化大致过程:M 初始化 --》 P 初始化 - -》 G 初始化mcommoninit Procresize newproc-------------------------------------------------------allm 池 allp 池 g.sched 执行现场p.runq 调度队列

M/P/G 初始化:mcommoninit、procresize、newproc,他们负责 M 资源池(allm)、p 资源池(allp)、G 的运行现场(g.sched) 以及调度队列(p.runq)

调度循环

所有的工作初始化完成后,就要启动运行器了。准备工作做好了,就要启动 mstart 了。这个工作在汇编语言中也可以看出来

/src/runtime/asm_amd64.s (在 linux 下)

CopyTEXT runtime·rt0_go(SB),NOSPLIT,$0

。。. 。。. 。。.

MOVL 16(SP), AX // copy argc

MOVL AX, 0(SP)

MOVQ 24(SP), AX // copy argv

MOVQ AX, 8(SP)

CALL runtime·args(SB)

CALL runtime·osinit(SB) //OS 初始化

CALL runtime·schedinit(SB) //调度器初始化

// create a new goroutine to start program

MOVQ $runtime·mainPC(SB), AX // entry

PUSHQ AX

PUSHQ $0 // arg size

CALL runtime·newproc(SB) // G 初始化

POPQ AX

// start this M , 启动 M

CALL runtime·mstart(SB)

CALL runtime·abort(SB) // mstart should never return

RET

转自:九卷

cnblogs.com/jiujuan/p/12977832.html

编辑:jq

原文标题:深入理解 Go scheduler 调度器:GPM 源码分析

文章出处:【微信号:LinuxHub,微信公众号:Linux爱好者】欢迎添加关注!文章转载请注明出处。

收藏 人收藏
分享:

评论

相关推荐

MSK调制解调器的matlab仿真

继续讲解程序!MSK也能进行相干解调?是的!同样是采用锁相环!先来看看MSK的优点,这是由于下面的这....
的头像 通信工程师专辑 发表于 09-18 11:43 102次 阅读
MSK调制解调器的matlab仿真

介绍3种方法跨时钟域处理方法

跨时钟域处理是FPGA设计中经常遇到的问题,而如何处理好跨时钟域间的数据,可以说是每个FPGA初学者....
的头像 FPGA设计论坛 发表于 09-18 11:33 617次 阅读
介绍3种方法跨时钟域处理方法

机智云追踪外卖骑手保温箱硬件开发和项目演示

01 本章实现功能介绍 追踪外卖骑手的保温箱的GPS定位信息以及外卖箱是否被人打开,以防止骑手在送餐....
的头像 机智云开发者 发表于 09-18 11:03 103次 阅读

深入探究Linux系统噪音统计(osnoise tracer)

在Linux系统中作为一个普通线程是非常苦逼的。不仅NMI 、硬中断、软中断可以打断它,甚至其它普通....
的头像 Linux阅码场 发表于 09-18 10:53 143次 阅读
深入探究Linux系统噪音统计(osnoise tracer)

avr单片机INT0是如何去模拟代码的

avr单片机INT0是如何去模拟代码的?怎样去编写其代码?...
发表于 09-18 06:49 0次 阅读

三菱交流伺服系统伺服故障和报警代码

伺服故障和报警代码大全,超实用!使用三菱交流伺服系统主要由三个系列:MR-ES、MR-J2S、MR-J3。通常故障情况可由伺服...
发表于 09-17 08:54 0次 阅读

如何利用51单片机制作从左至右再从右制作的流水灯呢

如何利用51单片机制作从左至右再从右制作的流水灯呢?如何编写其代码程序?...
发表于 09-17 06:52 0次 阅读

松下伺服报警代码保护功能

《松下伺服故障报警代码分析及处理》由会员分享,可在线阅读,更多相关《松下伺服故障报警代码分析及处理(2页珍藏版)》请在人人文...
发表于 09-17 06:20 0次 阅读

​开发板上玩GTA RISC-V多项移植项目成功运作中

电子发烧友网报道(文/周凯扬)RISC-V近期再度掀起了不小的热度,苹果招募RISC-V程序员负责其....
的头像 电子发烧友网 发表于 09-16 11:59 140次 阅读
​开发板上玩GTA RISC-V多项移植项目成功运作中

嵌入式开发中实用的宏打印函数

宏打印函数在我们的嵌入式开发中,使用printf打印一些信息是一种常用的调试手段。但是,在打印的信息....
的头像 FPGA之家 发表于 09-16 10:05 98次 阅读
嵌入式开发中实用的宏打印函数

使用Kotlin替代Java重构AOSP应用

两年前,Android 开源项目 (AOSP) 应用团队开始使用 Kotlin 替代 Java 重构....
的头像 谷歌开发者 发表于 09-16 09:26 101次 阅读
使用Kotlin替代Java重构AOSP应用

魔方网表,无代码开发平台NCDP的无冕之王

NCDP也就是No-code development platform,无代码开发平台,我第一次听到....
的头像 话说科技 发表于 09-15 14:34 85次 阅读

51单片机的启动文件作用是什么

在我们使用kei c51创建一个51单片机项目时,会有如下图所示的提示: 一般情况下,需要选择“是”....
的头像 嵌入式ARM 发表于 09-15 09:12 181次 阅读
51单片机的启动文件作用是什么

关节有哪几种不同的模式可以选择

CoppeliaSim笔记(3):关于关节的三种模式参考资料:CoppeliaSim User Manual (coppeliarobotics.com)(含源码)通过关节力...
发表于 09-15 08:46 0次 阅读

如何充分利用Heroku CI

ci/cd heroku 持续集成和持续交付(CI / CD)是当今软件工程开发过程中的最佳实践。  持续集成 (CI)允许开发人...
发表于 09-15 08:43 0次 阅读

代码生成有哪些用途

代码生成有许多用途:  我们可以从模式或现有信息源中生成重复代码。 例如,我们可以从数据库模式文件生成数据访问对象...
发表于 09-15 08:04 0次 阅读

3200故障代码服务器显示说明

3200故障代码 服务器显示 说 明AT400门机随机文件受控文件编号: AT400-OIM-ZH更 改 记 录序号更改文件号更 改 内 容 描...
发表于 09-15 07:51 0次 阅读

ros_control是怎样去控制真实电机的

ros_control是怎样去控制真实电机的?如何去编写其代码程序? ...
发表于 09-15 07:09 0次 阅读

力/力矩传感器的使用

1. 插件的添加在相应的标签内添加如下代码:                  3...
发表于 09-15 06:37 0次 阅读

FastThreadLocal快在哪里

blog.csdn.net/mycs2012/article/details/90898128 1 ....
的头像 Android编程精选 发表于 09-13 09:17 132次 阅读

C++基础语法友元类和友元函数

本期是C++基础语法分享的第五节,今天给大家来分享一下: (1)explicit(显式)关键字; (....
的头像 C语言编程学习基地 发表于 09-12 09:52 190次 阅读

一条SQL语句是怎么被执行的

一直是想知道一条SQL语句是怎么被执行的,它执行的顺序是怎样的,然后查看总结各方资料,就有了下面这一....
的头像 Linux爱好者 发表于 09-12 09:44 168次 阅读
一条SQL语句是怎么被执行的

简述hex文件解析源码

简述hex文件解析源码
发表于 09-12 09:20 10次 阅读

如何通过Python脚本实现WIFI密码的暴力破解

前言 本文将记录学习下如何通过 Python 脚本实现 WIFI 密码的暴力破解,从而实现免费蹭网。....
的头像 马哥Linux运维 发表于 09-10 17:09 323次 阅读
如何通过Python脚本实现WIFI密码的暴力破解

软件工程师为什么要写文档

在大多数软件工程师对编写、使用和维护代码的抱怨中,一个常见的问题是缺乏高质量的文档。缺乏文档有什么副....
的头像 Linux阅码场 发表于 09-09 11:26 249次 阅读

使用deepstream-test的范例代码修改车牌识别与遮盖

前一篇文章提到使用deepstream-test的范例代码,修改成“车牌识别”与“遮盖(redact....
的头像 NVIDIA英伟达企业解决方案 发表于 09-09 10:04 176次 阅读
使用deepstream-test的范例代码修改车牌识别与遮盖

在STM32G4片内不同存储空间运行的速度差异

最近有人问起程序在STM32G4片内不同存储空间运行的速度差异。说实在的,这个很难说死或说出个绝对的....
的头像 茶话MCU 发表于 09-09 09:57 235次 阅读
在STM32G4片内不同存储空间运行的速度差异

骑手保温箱追踪及温湿度监测4G设备接入机智云教程

01 前言 利用机智云提供的通用版App即使不懂云和App开发,也可以在不用写任何代码的情况下,轻松....
的头像 机智云开发者 发表于 09-09 09:16 147次 阅读
骑手保温箱追踪及温湿度监测4G设备接入机智云教程

Kitronik ARCADE游戏手柄实现连连看

连连看相信大家都玩过,但这个用Kitronik AR CADE游戏手柄来玩连连看的项目你相信是一个高....
的头像 电子森林 发表于 09-08 11:47 223次 阅读
Kitronik ARCADE游戏手柄实现连连看

如何把Docker Registry迁移到Harbor

“要如何将 docker registry 中的镜像迁移至 harbor?本文介绍了四种具体的思路和....
的头像 马哥Linux运维 发表于 09-07 16:29 300次 阅读
如何把Docker Registry迁移到Harbor

最为精简的一个Linux Fork炸弹解析

转自:http://blog.saymagic.cn/2015/03/25/fork-bomb.ht....
的头像 Linux爱好者 发表于 09-07 16:12 115次 阅读

使用Intellij IDEA的一些小技巧

https://blog.csdn.net/linsongbin1/article/details/....
的头像 Android编程精选 发表于 09-05 15:03 318次 阅读

内联汇编代码中的关键语法规则讲解

一、基本 asm 格式 1. 语法规则 2. test1.c 插入空指令 3. test2.c 操作....
的头像 硬件攻城狮 发表于 09-05 09:46 227次 阅读

C语言代码中的extern

在你的C语言代码中,不知能否看到类似下面的代码: 这好像没有什么问题,你应该还会想:“嗯⋯是啊,我们....
的头像 STM32嵌入式开发 发表于 09-02 15:13 205次 阅读
C语言代码中的extern

你们知道指针和引用正确的使用场景吗

先解决两个疑问 ◆ 指针和引用的不同之处是什么? ◆ 何时用用指针?何时用引用? 指针和引用的不同之....
的头像 STM32嵌入式开发 发表于 09-02 14:37 180次 阅读
你们知道指针和引用正确的使用场景吗

Vivado调用Questa Sim或ModelSim仿真小技巧

Vivado调用Questa Sim或ModelSim仿真中存在的一些自动化问题的解决方案。 Viv....
的头像 FPGA之家 发表于 09-02 10:12 203次 阅读
Vivado调用Questa Sim或ModelSim仿真小技巧

比Arduino更简单易用的开发套件ShineBlink

Hi 机友们,我想向你推荐一个小而美的产品,一个比Arduino更简单易用的开发套件——ShineB....
的头像 机智云物联网 发表于 09-02 10:04 578次 阅读

Go编译器已默认启用-G=3支持泛型

Go 项目代码仓库昨日提交和合并的一个 PR 显示,Go 语言已在 cmd/compile 中默认启....
的头像 马哥Linux运维 发表于 09-01 15:52 1210次 阅读
Go编译器已默认启用-G=3支持泛型

分享一个最新的的Python对象序列化方式

许多Python标准库都有一些未被赏识的精华。其中之一是允许简单优雅的基于参数类型的函数分发。这一特....
的头像 马哥Linux运维 发表于 09-01 15:19 674次 阅读
分享一个最新的的Python对象序列化方式

Go常用的加密算法详细解读

【导读】本文介绍了常用的加密算法,并对这些加密算法结合实际 golang 代码段进行了详细解读。 前....
的头像 开关电源芯片 发表于 09-01 14:47 127次 阅读

一文透析Nginx-ingress 控制器如何实现的

主机nginx 一般nginx做主机反向代理(网关)有以下配置 upstream order{ se....
的头像 Linux爱好者 发表于 09-01 14:44 869次 阅读
一文透析Nginx-ingress 控制器如何实现的

代码中是数学图像解法和贪心解法

今天讲一个贪心的老司机的故事,就是力扣第 134 题「加油站」: 题目应该不难理解,就是每到达一个站....
的头像 新材料在线 发表于 09-01 14:14 197次 阅读
代码中是数学图像解法和贪心解法

如何才能够翻转二叉树

这道题目是非常经典的题目,也是比较简单的题目(至少一看就会)。 但正是因为这道题太简单,一看就会,一....
的头像 新材料在线 发表于 09-01 11:45 221次 阅读

Python 代码加速运行的的小技巧

Python 是一种脚本语言,相比 C/C++ 这样的编译语言,在效率和性能方面存在一些不足。但是,....
的头像 Android编程精选 发表于 09-01 11:28 245次 阅读

K8S集群服务访问失败怎么办 K8S故障处理集锦

问题1:K8S集群服务访问失败?     原因分析:证书不能被识别,其原因为:自定义证书,过期等。 ....
的头像 开关电源芯片 发表于 09-01 11:11 248次 阅读
K8S集群服务访问失败怎么办 K8S故障处理集锦

全面解读图像局部特征点检测算法

研究图像特征检测已经有一段时间了,图像特征检测的方法很多,又加上各种算法的变形,所以难以在短时间内全....
的头像 尖刀视 发表于 09-01 10:19 182次 阅读
全面解读图像局部特征点检测算法

ADI-blackfin-PPI驱动TFT屏的代码-TFT-Init

ADI-blackfin-PPI驱动TFT屏的代码-TFT-Init(电源技术投稿模版)-ADI-b....
发表于 08-31 11:28 23次 阅读
ADI-blackfin-PPI驱动TFT屏的代码-TFT-Init

C语言冒泡排序工程代码汇总

C语言冒泡排序工程代码汇总
发表于 08-30 11:06 24次 阅读

为什么有时候会写出烂代码

本文的内容是最近我刚刚遇到的一个问题,问题代码是我自己写的,也是我自己写单元测试的时候发现的,也是我....
的头像 深圳东裕光大 发表于 08-27 10:23 244次 阅读
为什么有时候会写出烂代码

软件工程师加入新开发团队时需要思考的问题

‍‍ 作者 | Thomas Stringer 译者 | 弯月 出品 | CSDN(ID:CSDNn....
的头像 深圳东裕光大 发表于 08-27 10:14 238次 阅读

主流编程开发工具分享介绍

俗话说的好:工欲善其事,必先利其器。一款好的开发工具对程序员来说是至关重要的,可以降低开发成本、提高....
的头像 深圳东裕光大 发表于 08-27 10:09 248次 阅读

四个方面全面解析Linux 下 C++ 编译&链接

【导读】:编译与链接对CC++程序员既熟悉又陌生,熟悉在于每份代码都要经历编译与链接过程,陌生在于大....
的头像 开关电源芯片 发表于 08-27 09:36 2803次 阅读
四个方面全面解析Linux 下 C++ 编译&链接

怎么样才能让Java代码编写更规范化

作者 | 涛姐涛哥 链接 | cnblogs.com/taojietaoge/p/11575376.....
的头像 Android编程精选 发表于 08-27 09:31 1251次 阅读

如何使用Anbox在Jetson Nano 2GB上运行Android应用程序

**Jetson Nano 2GB是NVIDIA的一款高性价比嵌入式平台。麻雀虽小五脏俱全,战力强悍....
的头像 ICExpo 发表于 08-26 17:46 596次 阅读

如何测量ARM Cortex-M MCU代码的执行时间

在许多实时应用中,如电机控制、发动机控制、无线通信等时间敏感的应用,CPU可能花费不到5%的时间执行....
的头像 奈因PCB电路板设计 发表于 08-26 09:20 323次 阅读
如何测量ARM Cortex-M MCU代码的执行时间

网络IO的弊端以及多路复用IO的优势

为了讲多路复用,当然还是要跟风,采用鞭尸的思路,先讲讲传统的网络 IO 的弊端,用拉踩的方式捧起多路....
的头像 开关电源芯片 发表于 08-25 18:01 496次 阅读
网络IO的弊端以及多路复用IO的优势

深度解读LabVIEW的彩色*obj文件读取及渲染

随着应用场合的增多,扫描设备不仅得到物体的三维坐标信息,也得到了物体的纹理信息。*.OBJ三维文件格....
的头像 Q哥学逆向 发表于 08-25 17:41 1785次 阅读

二分搜索算法运用的框架套路

我们前文 我作了首诗,保你闭着眼睛也能写对二分查找 详细介绍了二分搜索的细节问题,探讨了「搜索一个元....
的头像 算法与数据结构 发表于 08-25 16:06 240次 阅读

2021年10种最受欢迎的微控制器

MCU(微控制器)——今年的涨价王者! 无论是DIY还是专业产品,任何嵌入式电子设备的核心都是微控制....
的头像 佐思汽车研究 发表于 08-25 14:15 502次 阅读

CPU如何执行代码 汇编语言教程

学习编程其实就是学高级语言,即那些为人类设计的计算机语言。 但是,计算机不理解高级语言,必须通过编译....
的头像 奈因PCB电路板设计 发表于 08-25 11:14 194次 阅读
CPU如何执行代码 汇编语言教程