El proceso de desarrollo durante la depuración de código que los desarrolladores a menudo tienen que hacer una cosa, El lenguaje GO como PHP, Python y otros lenguajes dinámicos, siempre y cuando las modificaciones no necesitan compilar puede ser directamente ir a la producción, dinámicamente en entornos de ejecución de datos de impresión . Por supuesto Go también puede println los datos de impresión a depurar, pero necesita volver a compilar cada vez, lo cual es algo muy molesto. Sabemos que en Python con herramientas pdb / IPDB como la depuración, JavaScript tiene herramientas similares que son capaces de mostrar dinámicamente información variable, en una sola etapa de depuración. Pero afortunadamente Go tiene un soporte herramienta similar: GDB. Go dentro tiene compatibilidad integrada para el IAE, así que podemos GDB para la depuración, entonces esta sección presentaremos cómo GDB para depurar el programa Go
GDB es la FSF (Free Software Foundation) publicó un potente sistema de tipo UNIX bajo la herramienta de depuración del programa. Usando El GDB puede hacer las siguientes cosas:
- Iniciar el programa, puede personalizar de acuerdo a las necesidades del desarrollador para ejecutar el programa.
- Permite que el programa que se está depurando estableciendo el tono en el desarrollo de la casa se detuvo en un punto de interrupción. (Puntos de interrupción puede ser expresión condicional)
- Cuando se detiene el programa, se puede consultar el programa en este momento lo que pasó.
- Para cambiar dinámicamente el entorno de ejecución del programa actual.
Programa Go es compatible actualmente con la versión del depurador GDB debe ser mayor que 7,1.
Vaya programa compilado los siguientes puntos deben tenerse en cuenta cuando se
- Pasar parámetros-ldflags "-s", ignorando la información de depuración de impresión
- Pase-gcflags "-Nl" de parámetros, por lo que puede pasar por alto Entrar para hacer un poco de optimización, optimización de variables y funciones de agregado, etc, por lo que para el BGF depurador es muy difícil, por lo que en tiempo de compilación para unirse a estos dos parámetros para evitar estos optimización.
GDB de algunos comandos más utilizados son los siguientes
- lista
Abreviado comando l , se utiliza para mostrar el código fuente, la pantalla predeterminada diez líneas de código, se puede traer de vuelta a una pantalla de parámetros de línea específico, por ejemplo: la lista 15 , exhibición de diez líneas de código, de las cuales las primeras 15 filas que se muestran en el interior diez líneas en el centro, como se muestra a continuación.
10 time.Sleep(2 * time.Second)
11 c <- i
12 }
13 close(c)
14 }
15
16 func main() {
17 msg := "Starting main"
18 fmt.Println(msg)
19 bus := make(chan int)-
rotura Abreviado comando b , que se utiliza para establecer puntos de interrupción, seguido por el número de filas de ajuste de parámetros, tales como puntos de interrupción b 10 establece un punto de quiebre en el décimo consecutivo.
-
borrar Abreviada comando d , para eliminar un punto de quiebre, el punto de quiebre se sitúa seguido del número de serie, el número de serie se puede obtener a través de los puntos de interrupción
info breakpointsconjunto de puntos correspondiente número de serie se muestra de la siguiente manera para configurar un número de punto de descanso.Num Type Disp Enb Address What 2 breakpoint keep y 0x0000000000400dc3 in main.main at /home/xiemengjun/gdb.go:23 breakpoint already hit 1 time
-
backtrace
Comando abreviado BT , el proceso utilizado para imprimir la ejecución del código, de la siguiente manera:
#0 main.main () at /home/xiemengjun/gdb.go:23
#1 0x000000000040d61e in runtime.main () at /home/xiemengjun/go/src/pkg/runtime/proc.c:244
#2 0x000000000040d6c1 in schedunlock () at /home/xiemengjun/go/src/pkg/runtime/proc.c:267
#3 0x0000000000000000 in ?? ()- info
comando info para mostrar información, seguido de varios parámetros, hemos utilizado las siguientes categorías:
info locals
Muestra los valores de las variables del programa actualmente en ejecución
info breakpoints
Mostrar una lista de puntos de interrupción establecidos actualmente
info goroutines
Goroutine muestra la lista actual de la ejecución, como se muestra en el código, como * indica la ejecución actualn
* 1 running runtime.gosched
* 2 syscall runtime.entersyscall
3 waiting runtime.gosched
4 runnable runtime.goschedAbreviado comando p , u otra información que se utiliza para imprimir la variable, seguido del nombre de la variable que se va a imprimir, por supuesto, hay algunos muy útil la función $ len () y $ cap (), se utiliza para devolver la cadena actual, rebanadas o mapas de la longitud y capacidad.
- whatis
Se utiliza para mostrar el tipo de variable actual, seguido del nombre de la variable, por ejemplo, whatis msg , se muestra a continuación:
type = struct string
- next
Abreviado comando n , para depuración paso a paso, omita el siguiente paso, cuando hay un punto de ruptura, puede introducir n saltar al siguiente paso para continuar
- continue
Comando abreviado c , al saltar del punto de ruptura actual puede ser seguido por el parámetro N, el número de veces que el punto de quiebre se saltó
- set variable
Este comando se utiliza para cambiar el valor de una variable durante la operación, los formatos como: set variable <var> = <value>
Utilizamos el siguiente código para demostrar cómo este GDB para depurar el programa Go, el siguiente es el código que se demostró:
package main
import (
"fmt"
"time"
)
func counting(c chan<- int) {
for i := 0; i < 10; i++ {
time.Sleep(2 * time.Second)
c <- i
}
close(c)
}
func main() {
msg := "Starting main"
fmt.Println(msg)
bus := make(chan int)
msg = "starting a gofunc"
go counting(bus)
for count := range bus {
fmt.Println("count:", count)
}
}Archivo compilado, un gdbfile archivo ejecutable:
go build -gcflags "-N -l" gdbfile.goPor orden GDB puede iniciar la depuración::
gdb gdbfileDespués de la primera apertura, no es posible considerar este programa en funcionamiento, basta con escribir run comando después de que el programa comienza a trabajar, correctamente, entonces usted puede ver la salida del programa es el siguiente, y ejecutar el programa directamente de la salida de línea de comandos es la misma:
(gdb) run
Starting program: /home/xiemengjun/gdbfile
Starting main
count: 0
count: 1
count: 2
count: 3
count: 4
count: 5
count: 6
count: 7
count: 8
count: 9
[LWP 2771 exited]
[Inferior 1 (process 2771) exited normally] Bueno, ahora que sabemos cómo hacer que el programa suba, vamos a dar el código para establecer un punto de quiebre:
(gdb) b 23
Breakpoint 1 at 0x400d8d: file /home/xiemengjun/gdbfile.go, line 23.
(gdb) run
Starting program: /home/xiemengjun/gdbfile
Starting main
[New LWP 3284]
[Switching to LWP 3284]
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
23 fmt.Println("count:", count)El ejemplo anterior muestra el b 23 establece un punto de interrupción en la línea 23, a continuación, introduzca ejecutar iniciar el programa en ejecución. Ahora, el programa en lugar de establecer un punto de quiebre en frente se detuvo, tenemos que mirar el contexto del punto de ruptura del código fuente correspondiente, escriba la lista se puede ver la pantalla de la línea de la fuente de corriente antes de parar cinco aperturas:
(gdb) list
18 fmt.Println(msg)
19 bus := make(chan int)
20 msg = "starting a gofunc"
21 go counting(bus)
22 for count := range bus {
23 fmt.Println("count:", count)
24 }
25 }GDB ahora ejecutar el entorno del programa actual ha conservado algo de información de depuración útil, sólo imprimimos las variables correspondientes, consulte los correspondientes tipos y valores de las variables:
(gdb) info locals
count = 0
bus = 0xf840001a50
(gdb) p count
$1 = 0
(gdb) p bus
$2 = (chan int) 0xf840001a50
(gdb) whatis bus
type = chan intLuego deje que el programa continúe hasta la ejecución, por favor lea el siguiente comando:
(gdb) c
Continuing.
count: 0
[New LWP 3303]
[Switching to LWP 3303]
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
23 fmt.Println("count:", count)
(gdb) c
Continuing.
count: 1
[Switching to LWP 3302]
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
23 fmt.Println("count:", count)Después de cada entrada c se ejecutará el código una vez, y pasar al siguiente bucle, continúe para imprimir la información apropiada.
Supongamos que la necesidad actual para cambiar las variables de contexto, omitiendo el proceso y continuar con el siguiente paso, los resultados deseados modificados obtenidos:
(gdb) info locals
count = 2
bus = 0xf840001a50
(gdb) set variable count=9
(gdb) info locals
count = 9
bus = 0xf840001a50
(gdb) c
Continuing.
count: 9
[Switching to LWP 3302]
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
23 fmt.Println("count:", count) Por último, un poco de imaginación, en frente de todo el programa se está ejecutando en el proceso, al final creó un goroutine número, cada goroutine están haciendo:
(gdb) info goroutines
* 1 running runtime.gosched
* 2 syscall runtime.entersyscall
3 waiting runtime.gosched
4 runnable runtime.gosched
(gdb) goroutine 1 bt
#0 0x000000000040e33b in runtime.gosched () at /home/xiemengjun/go/src/pkg/runtime/proc.c:927
#1 0x0000000000403091 in runtime.chanrecv (c=void, ep=void, selected=void, received=void)
at /home/xiemengjun/go/src/pkg/runtime/chan.c:327
#2 0x000000000040316f in runtime.chanrecv2 (t=void, c=void)
at /home/xiemengjun/go/src/pkg/runtime/chan.c:420
#3 0x0000000000400d6f in main.main () at /home/xiemengjun/gdbfile.go:22
#4 0x000000000040d0c7 in runtime.main () at /home/xiemengjun/go/src/pkg/runtime/proc.c:244
#5 0x000000000040d16a in schedunlock () at /home/xiemengjun/go/src/pkg/runtime/proc.c:267
#6 0x0000000000000000 in ?? ()Comandos de visualización goroutines podemos entender claramente goruntine realiza internamente cómo cada secuencia de llamada a la función se ha demostrado claramente.
En esta sección se presenta el programa Go depurador GDB algunos comandos básicos, incluyendo run, print, info, set variable, continue, list, break y otros comandos de depuración de uso frecuente, por los ejemplos anteriores demuestran, a mi juicio, a través del depurador GDB para que el lector tiene un conocimiento básico de los programas de Go, si desea obtener más consejos de depuración, consulte el sitio web oficial del manual depurador GDB, así como el sitio web oficial del manual de GDB.
- Directory
- Previous section: Error handling
- Next section: Write test cases