gdb默认是通过ptrace系统调用实现功能，本文简单了解ptrace。
# ptrace
ptrace的系统调用
```
/* kernel/ptrace.c */
#define __NR_ptrace 117
__SYSCALL(__NR_ptrace, sys_ptrace)
```
在使用ptrace时需要包含`/sys/ptrace.h` ，调用ptrace系统调用的时候，需要根据不同的request来发送请求，request的种类如下
```
enum __ptrace_request
{
  /* Indicate that the process making this request should be traced.
     All signals received by this process can be intercepted by its
     parent, and its parent can use the other `ptrace' requests.  */
  PTRACE_TRACEME = 0,
#define PT_TRACE_ME PTRACE_TRACEME

  /* Return the word in the process's text space at address ADDR.  */
  PTRACE_PEEKTEXT = 1,
#define PT_READ_I PTRACE_PEEKTEXT

  /* Return the word in the process's data space at address ADDR.  */
  PTRACE_PEEKDATA = 2,
#define PT_READ_D PTRACE_PEEKDATA

  /* Return the word in the process's user area at offset ADDR.  */
  PTRACE_PEEKUSER = 3,
#define PT_READ_U PTRACE_PEEKUSER

  /* Write the word DATA into the process's text space at address ADDR.  */
  PTRACE_POKETEXT = 4,
#define PT_WRITE_I PTRACE_POKETEXT

  /* Write the word DATA into the process's data space at address ADDR.  */
  PTRACE_POKEDATA = 5,
#define PT_WRITE_D PTRACE_POKEDATA

  /* Write the word DATA into the process's user area at offset ADDR.  */
  PTRACE_POKEUSER = 6,
#define PT_WRITE_U PTRACE_POKEUSER

  /* Continue the process.  */
  PTRACE_CONT = 7,
#define PT_CONTINUE PTRACE_CONT

  /* Kill the process.  */
  PTRACE_KILL = 8,
#define PT_KILL PTRACE_KILL

  /* Single step the process.  */
  PTRACE_SINGLESTEP = 9,
#define PT_STEP PTRACE_SINGLESTEP

  /* Get all general purpose registers used by a processes.  */
  PTRACE_GETREGS = 12,
#define PT_GETREGS PTRACE_GETREGS

  /* Set all general purpose registers used by a processes.  */
  PTRACE_SETREGS = 13,
#define PT_SETREGS PTRACE_SETREGS
  /* Get all floating point registers used by a processes.  */
  PTRACE_GETFPREGS = 14,
#define PT_GETFPREGS PTRACE_GETFPREGS

  /* Set all floating point registers used by a processes.  */
  PTRACE_SETFPREGS = 15,
#define PT_SETFPREGS PTRACE_SETFPREGS

  /* Attach to a process that is already running. */
  PTRACE_ATTACH = 16,
#define PT_ATTACH PTRACE_ATTACH

  /* Detach from a process attached to with PTRACE_ATTACH.  */
  PTRACE_DETACH = 17,
#define PT_DETACH PTRACE_DETACH

  /* Get all extended floating point registers used by a processes.  */
  PTRACE_GETFPXREGS = 18,
#define PT_GETFPXREGS PTRACE_GETFPXREGS

  /* Set all extended floating point registers used by a processes.  */
  PTRACE_SETFPXREGS = 19,
#define PT_SETFPXREGS PTRACE_SETFPXREGS

  /* Continue and stop at the next entry to or return from syscall.  */
  PTRACE_SYSCALL = 24,
#define PT_SYSCALL PTRACE_SYSCALL

  /* Get a TLS entry in the GDT.  */
  PTRACE_GET_THREAD_AREA = 25,
#define PT_GET_THREAD_AREA PTRACE_GET_THREAD_AREA

  /* Change a TLS entry in the GDT.  */
  PTRACE_SET_THREAD_AREA = 26,
#define PT_SET_THREAD_AREA PTRACE_SET_THREAD_AREA

  /* Continue and stop at the next syscall, it will not be executed.  */
  PTRACE_SYSEMU = 31,
#define PT_SYSEMU PTRACE_SYSEMU

  /* Single step the process, the next syscall will not be executed.  */
  PTRACE_SYSEMU_SINGLESTEP = 32,
#define PT_SYSEMU_SINGLESTEP PTRACE_SYSEMU_SINGLESTEP

  /* Execute process until next taken branch.  */
  PTRACE_SINGLEBLOCK = 33,
#define PT_STEPBLOCK PTRACE_SINGLEBLOCK

  /* Set ptrace filter options.  */
  PTRACE_SETOPTIONS = 0x4200,
#define PT_SETOPTIONS PTRACE_SETOPTIONS
  /* Get last ptrace message.  */
  PTRACE_GETEVENTMSG = 0x4201,
#define PT_GETEVENTMSG PTRACE_GETEVENTMSG

  /* Get siginfo for process.  */
  PTRACE_GETSIGINFO = 0x4202,
#define PT_GETSIGINFO PTRACE_GETSIGINFO

  /* Set new siginfo for process.  */
  PTRACE_SETSIGINFO = 0x4203,
#define PT_SETSIGINFO PTRACE_SETSIGINFO

  /* Get register content.  */
  PTRACE_GETREGSET = 0x4204,
#define PTRACE_GETREGSET PTRACE_GETREGSET

  /* Set register content.  */
  PTRACE_SETREGSET = 0x4205,
#define PTRACE_SETREGSET PTRACE_SETREGSET

  /* Like PTRACE_ATTACH, but do not force tracee to trap and do not affect
     signal or group stop state.  */
  PTRACE_SEIZE = 0x4206,
#define PTRACE_SEIZE PTRACE_SEIZE

  /* Trap seized tracee.  */
  PTRACE_INTERRUPT = 0x4207,
#define PTRACE_INTERRUPT PTRACE_INTERRUPT

  /* Wait for next group event.  */
  PTRACE_LISTEN = 0x4208,
#define PTRACE_LISTEN PTRACE_LISTEN

  /* Retrieve siginfo_t structures without removing signals from a queue.  */
  PTRACE_PEEKSIGINFO = 0x4209,
#define PTRACE_PEEKSIGINFO PTRACE_PEEKSIGINFO

  /* Get the mask of blocked signals.  */
  PTRACE_GETSIGMASK = 0x420a,
#define PTRACE_GETSIGMASK PTRACE_GETSIGMASK

  /* Change the mask of blocked signals.  */
  PTRACE_SETSIGMASK = 0x420b,
#define PTRACE_SETSIGMASK PTRACE_SETSIGMASK

  /* Get seccomp BPF filters.  */
  PTRACE_SECCOMP_GET_FILTER = 0x420c,
#define PTRACE_SECCOMP_GET_FILTER PTRACE_SECCOMP_GET_FILTER

  /* Get seccomp BPF filter metadata.  */
  PTRACE_SECCOMP_GET_METADATA = 0x420d,
#define PTRACE_SECCOMP_GET_METADATA PTRACE_SECCOMP_GET_METADATA

  /* Get information about system call.  */
  PTRACE_GET_SYSCALL_INFO = 0x420e,
#define PTRACE_GET_SYSCALL_INFO PTRACE_GET_SYSCALL_INFO

  /* Get rseq configuration information.  */
  PTRACE_GET_RSEQ_CONFIGURATION = 0x420f
#define PTRACE_GET_RSEQ_CONFIGURATION PTRACE_GET_RSEQ_CONFIGURATION
};
```
不同的ptrace请求上面其实存在简要的注释，如果需要详细了解，可以man-page链接查看
> https://man7.org/linux/man-pages/man2/ptrace.2.html

# gdb如何调用ptrace
针对gdb，我们可以准备一个简单的hello world程序，然后使用gdb进行调试。查看一个简单的hello world是如何进行ptrace调用的。简单的程序如下
```
int main() { printf("hello \n");}
```
因为ptrace是系统调用，可以直接使用`perf trace -e`抓取，如下
```
gcc test.c -o test
perf trace -e ptrace -p $(pidof gdb)
```
运行日志如下
```
     0.000 ( 0.007 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603456)                 = 0
     0.010 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607008)              = 0
     0.049 ( 0.002 ms): gdb/6228 ptrace(request: 7, pid: 6249, addr: 0x1)                              = 0
     0.836 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603456)                 = 0
     0.840 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607008)              = 0
     0.854 ( 0.001 ms): gdb/6228 ptrace(request: 16896, pid: 6249, data: 1048639)                      = 0
     0.886 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x88, data: 140731401607416)      = 0
     0.888 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0xb8, data: 140731401607416)      = 0
     0.901 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604736)                 = 0
    10.369 ( 0.005 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604352)                 = 0
    10.375 ( 0.002 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604352)                 = 0
    10.396 ( 0.001 ms): gdb/6228 ptrace(request: 7, pid: 6249, addr: 0x1)                              = 0
    10.560 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604064)                 = 0
    10.564 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607616)              = 0
    10.566 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604096)                 = 0
    10.568 ( 0.001 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604096)                 = 0
    10.666 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603440)                 = 0
    10.670 ( 0.001 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401603440)                 = 0
    10.675 ( 0.002 ms): gdb/6228 ptrace(request: 9, pid: 6249, addr: 0x1)                              = 0
    10.687 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604064)                 = 0
    10.690 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607616)              = 0
    10.692 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x380, data: 140731401607256)     = 0
    10.709 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604272)                 = 0
    10.711 ( 0.001 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604272)                 = 0
    10.716 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x380, data: 140731401607768)     = 0
    10.721 ( 0.002 ms): gdb/6228 ptrace(request: 7, pid: 6249, addr: 0x1)                              = 0
    10.860 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604064)                 = 0
    10.864 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607616)              = 0
    10.866 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604096)                 = 0
    10.869 ( 0.002 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604096)                 = 0
    92.068 ( 0.006 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0xa8, data: 140731401605624)      = 0
    92.244 ( 0.003 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603440)                 = 0
    92.249 ( 0.002 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401603440)                 = 0
    92.257 ( 0.003 ms): gdb/6228 ptrace(request: 9, pid: 6249, addr: 0x1)                              = 0
    92.393 ( 0.002 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401603936)                 = 0
    92.397 ( 0.001 ms): gdb/6228 ptrace(request: 16898, pid: 6249, data: 140731401607488)              = 0
    92.400 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x380, data: 140731401607128)     = 0
    92.459 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0xa8, data: 140731401607128)      = 0
    92.469 ( 0.001 ms): gdb/6228 ptrace(request: 12, pid: 6249, data: 140731401604272)                 = 0
    92.471 ( 0.001 ms): gdb/6228 ptrace(request: 13, pid: 6249, data: 140731401604272)                 = 0
    92.477 ( 0.001 ms): gdb/6228 ptrace(request: 3, pid: 6249, addr: 0x380, data: 140731401607768)     = 0
    92.482 ( 0.001 ms): gdb/6228 ptrace(request: 7, pid: 6249, addr: 0x1)                              = 0
```
可以看到，gdb频繁的调用ptrace来获取寄存器并修改指针寄存器的值。
# 如何防止程序被调试
根据man-page的文档，可以知道，ptrace只能被一个人去attach，所以防止程序被调试的方法很简单，那就是主动调用TRACEME让父进程来调试自己， 如下
```
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/prctl.h>
#include <sys/ptrace.h>

int main()
{
    if (ptrace(PTRACE_TRACEME, 0, 0, 0) < 0 ) {
        exit(42);
    }
    while(1) {
        printf("hello \n");
        sleep(1);
    }
    return 0;
}
```
这里使用PTRACE_TRACEME来让父进程调试自己，那么可以从程序运行后看到如下信息
```
# cat /proc/$(pidof hello)/status | grep TracerPid
TracerPid:      5071
```
这里可以看到自己被attach的pid是5071，而5071是自己程序运行的父进程bash。此时因为ptrace只能被一个人trace，所有其他的程序无法调试它。此时可以尝试gdb调试此程序
```
# gdb attach 6526
Attaching to process 6526
Could not attach to process.  If your uid matches the uid of the target
process, check the setting of /proc/sys/kernel/yama/ptrace_scope, or try
again as the root user.  For more details, see /etc/sysctl.d/10-ptrace.conf
warning: process 6526 is already traced by process 5071
```
可以看到其他程序无法调试此程序。

同样的程序也无法在运行时被调试，如下
```
# gdb ./hello
(gdb) r
Starting program: /root/gdb/hello
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[Inferior 1 (process 6578) exited with code 052]
```
# 总结
到了这里，可以知道了gdb本身是ptrace的封装，其利用内核实现的ptrace机制来完成程序的调试，从而获取当前代码运行时刻的寄存器，内存，栈等相关信息。

那么我有一个问题，如何尝试让TracerPid为0，从而伪装自身并未已被参与调试。

gdb调试方法(2)-ptrace

gdb是工作中常用的调试工具，朋友说要介绍一下gdb的使用方法，思考了一下，遂打算整理自己的gdb经验，总结出来作为一个系列，一方面用作巩固自己的基础知识，另一方面用来分享自己的一些经验和技巧。

# 参考资料
我使用gdb的所有技巧来源于两个链接，如果想一手资料学习理解，可以进如下链接学习

## gdb文档
> https://sourceware.org/gdb

这里是gdb的官方文档位置，会每日构建文档查看，链接如下

> https://sourceware.org/gdb/current/onlinedocs/gdb.html

pdf版本
> https://sourceware.org/gdb/current/onlinedocs/gdb.pdf

## 100个gdb技巧
> https://github.com/hellogcc/100-gdb-tips

这是整理的关于gdb的中文文档

# 总结
如果需要了解gdb的使用，上述文档完全能够达成目的。接下来主要针对自己的gdb经验做一个总结，和上述内容仅技术相关。

gdb调试方法(1)-介绍

经常在不同的设备上进行调试，所以不断的attach，但是因为笔记本，台式机，linux，windows来回切换，导致tmux的窗口有时发生变化。

本来这事情很简单，没什么必要记下来，但这种事情又发生很多次了，但每次隔一段时间就忘，此时为了加强记忆，遂记录一下。

下面说明出现窗口大小问题后的处理。

# 处理办法
这个问题处理办法很简单，就是经常容易忘而已，如下
```
ctrl + b 后加上 shift + d
```
值得注意的是，这样会把原来机器的tmux挤走，所以回到原来机器上时，再attach回来即可。

tmux窗口大小问题

frp是非常热门的高性能反代应用，可以轻松的做到内网穿透，我们在开发过程中，经常需要将一些机器的调试口短暂暴露出来，这样就可以随时随地的开发了，本文基于frp介绍一下如何配置，提高开发效率
# 下载
直接上github找最近的release即可
```
https://github.com/fatedier/frp/
```
当前是0.64.0。

![image.png](/static/img/c650bb8b513e081ad31089cc3998e750.image.webp)

下载frp主要分主机和调试机器，主机在amd64上，所以如下下载，而其他架构则是自己的调试机器，我的机器比较多，所以下面几个机器我都配好了。
* jetson orin
* 3a6000
* rk3588
* ft2000
* hi616
* h6
* intel nuc

上述机器根据不同的架构下载不同的linux二进制即可。
```
wget https://github.com/fatedier/frp/releases/download/v0.64.0/frp_0.64.0_linux_xxx.tar.gz
```

下载之后解压，里面有服务端配置和客户端配置，下面介绍配置

# 服务端
服务端是需要公网ip的，默认简单配置如下
```
# frps.toml
bindPort = 1111                                  
auth.token = "********"            
```
运行如下
```
./frps -c frps.toml
```
然后编写一个简单的systemd service即可。
```
[Unit]
Description=FRP Server

[Service]
Type = simple
ExecStart = /pathtofrp/run.sh

[Install]
WantedBy=multi-user.target
```
然后安装激活服务即可
```
cp frps.service /usr/lib/systemd/system/
systemctl enable frps
systemctl start frps
```
# 客户端
客户端是自己的设备机器，默认22端口最多，其他情况下vnc 5900端口或者其他web端口都可以，自行配置即可，我以22为例介绍，配置如下
```
# frpc.toml
serverAddr = "***********"
serverPort = 2222                  

auth.token = "********"        

[[proxies]]
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 3333
```
同样运行如下
```
./frpc -c frpc.toml
```
编写成服务如下
```
[Unit]
Description=FRP Client

[Service]
Type = simple
ExecStart = /pathtofrp/run.sh

[Install]
WantedBy=multi-user.target
```
激活服务如下
```
cp frpc.service /usr/lib/systemd/system/
systemctl enable frpc
systemctl start frpc
```

# 提醒
服务端暴露的端口1111是服务主机端口，而客户端链接端口2222是公网端口，这里代理设置端口3333是公网给localPort的连接的端口。

# 总结
frp作为免费开源的反代程序，其配置和使用也非常轻松易用。非常方便软件开发者进行远程开发。


使用frp远程调试开发板

tensorflow虽然现在不如torch那么流行，但是胜在稳定和早期应用的兼容落地优势，而且nvidia在安装tensorflow上几乎不会存在问题，nvidia提供了tensorflow的预编译二进制，我们可以直接拉取安装即可，本文基于nvidia的预编译二进制来说明tensorflow的安装过程
# 环境准备
首先我们可以根据nvidia的官网说明进行安装，但是需要提前知道的是，nvidia官网提供的文档通常是过时的，这种情况下我们不能全信官网。  
第一步，我们需要安装依赖，如下
```
$ sudo apt-get update
$ sudo apt-get install libhdf5-serial-dev hdf5-tools libhdf5-dev zlib1g-dev zip libjpeg8-dev liblapack-dev libblas-dev gfortran
```
然后安装python的依赖，安装之前，记得切到自己miniconda的环境，如下
```
# venv
```
值得注意的是，nvidia官网提供的安装方法，指定了当时的版本，现在的版本肯定需要升级，所以我们需要修正一下，也就是去掉版本号，如下
```
pip3 install -U future mock keras_preprocessing keras_applications  gast protobuf pybind11 cython pkgconfig packaging h5py 
```
一切就绪之后，我们登录nvidia的预发布平台查看tensorflow的二进制，如下
```
https://developer.download.nvidia.com/compute/redist/jp/v61/tensorflow/
```

![](http://139.227.85.143:9990/static/img/b7b4535ee96367138f40e50efe57b99e.image.webp)

此时直接下载即可，如下
```
wget https://developer.download.nvidia.com/compute/redist/jp/v61/tensorflow/tensorflow-2.16.1+nv24.08-cp310-cp310-linux_aarch64.whl
```
下载后安装
```
pip install tensorflow-2.16.1+nv24.08-cp310-cp310-linux_aarch64.whl
```
安装后，查看pip的list如下
```
# pip list  
Package                      Version                   Editable project location
---------------------------- ------------------------- -------------------------
absl-py                      2.3.1
astunparse                   1.6.3
certifi                      2025.8.3
charset-normalizer           3.4.3
cmake                        4.1.0
Cython                       3.1.3
filelock                     3.18.0
flatbuffers                  25.2.10
fsspec                       2025.7.0
future                       0.18.2
gast                         0.4.0
google-pasta                 0.2.0
grpcio                       1.74.0
h5py                         3.14.0
idna                         3.10
Jinja2                       3.1.6
keras                        3.11.2
Keras-Applications           1.0.8
Keras-Preprocessing          1.1.2
libclang                     18.1.1
Markdown                     3.8.2
markdown-it-py               4.0.0
MarkupSafe                   3.0.2
mdurl                        0.1.2
ml-dtypes                    0.3.2
mock                         3.0.5
mpmath                       1.3.0
namex                        0.1.0
networkx                     3.4.2
ninja                        1.13.0
numpy                        1.26.1
opt_einsum                   3.4.0
optree                       0.17.0
packaging                    25.0
pillow                       11.3.0
pip                          25.1
pkgconfig                    1.5.5
protobuf                     4.25.8
pybind11                     3.0.0
Pygments                     2.19.2
requests                     2.32.4
rich                         14.1.0
setuptools                   78.1.1
six                          1.17.0
sympy                        1.13.1
tensorboard                  2.16.2
tensorboard-data-server      0.7.2
tensorflow                   2.16.1+nv24.8
tensorflow-io-gcs-filesystem 0.37.1
termcolor                    3.1.0
torch                        2.5.0a0+872d972e41.nv24.8
torchaudio                   2.5.1a0+1661daf           /root/github/audio/src
torchvision                  0.20.1a0+3ac97aa
typing_extensions            4.14.1
urllib3                      2.5.0
Werkzeug                     3.1.3
wheel                        0.45.1
wrapt                        1.17.3
```
可以看到此环境安装了tensorflow 2.16.1版本。后续开发基于此版本

安装完成之后简单测试验证一下有效性，如下
```
import tensorflow as tf
from tensorflow.python.client import device_lib

print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
print(device_lib.list_local_devices())
```
运行日志如下
```
>>> print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
Num GPUs Available:  1
>>> print(device_lib.list_local_devices())
2025-08-16 12:36:53.123617: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1928] Created device /device:GPU:0 with 3786 MB memory:  -> device: 0, name: Orin, pci bus id: 0000:00:00.0, compute capability: 8.7
[name: "/device:CPU:0"
device_type: "CPU"
memory_limit: 268435456
locality {
}
incarnation: 3423392063243993720
xla_global_id: -1
, name: "/device:GPU:0"
device_type: "GPU"
memory_limit: 3970121728
locality {
  bus_id: 1
  links {
  }
}
incarnation: 6102036499595040418
physical_device_desc: "device: 0, name: Orin, pci bus id: 0000:00:00.0, compute capability: 8.7"
xla_global_id: 416903419
]
```
可以看到，正常识别到Orin平台的GPU设备了

# 总结
到这里，tensorflow的安装完成了，可以发现比安装pytorch轻松很多。

# 参考文档
> https://docs.nvidia.com/deeplearning/frameworks/install-tf-jetson-platform/index.html