Dragonboard Hexagon DSP
This page will help you setting up your environment to execute code on the Hexagon DSP on apq8016 (db410c), apq8096 (db820c), and qcs404. On qcs404 it's possible to use the cDSP in addition to the aDSP.
- Environment Setup
- Install Linaro Toolchain
- Install Hexagon SDK
- Build Kernel
- Build userspace libraries and daemons
- Copy libraries to Hexagon SDK
- Setup userspace tools
- Test your setup
- Building matrix_multi application
- Building calculator application from SDK
- Build and run TensorFlow Trained model with Hexagon NN on DB845c CDSP
- Running Inception v3 with SNPE
- Linux based host machine.
- DragonBoard 410c or 820c running debian. You can get 96boards images here. The installation instructions are pretty straightforward and can be found here.
- The Linaro Toolchain.
- The Hexagon SDK.
- A Linux kernel tree with support for the adsprpc driver.
- For db410c, you need the apq8016 modem firmware files r1036.1 to get FastRPC support. These files are released through the Qualcomm Developer Network. You'll need to replace the files /lib/firmware/modem.* in your stock rootfs with the r1036.1 ones.
- For db820c, the public archive linux-board-support-package-r01700.1.zip contains the needed adsp firwmares.
For the purpose of this documentation, let's say your working directory is ~/dev.
To compile the Linux kernel and also the Hexagon sample applications you'll need the aarch64 Linaro toolchain. Download the archive named as gcc-linaro-x.y.z-201Y.MM-x86_64_aarch64-linux-gnu.tar.xz and decompress it into your ~/dev folder.
Eventually you may add the bin sub-folder of the Linaro toolchain to your $PATH environment variable. This is needed to cross-compile libadsprpc.so if you want to build it from your host.
You need to install the Hexagon SDK to compile the sample application. The SDK can be downloaded here. You can choose version 3.4.1.
Once installed, you need a couple of extra steps to be able to compile the example.
In order to compile the sample applications using the standard Linux target you must add the Linaro toolchain to the Hexagon SDK.
This is usually done by copying the Linaro toolchain into the SDK tools sub-folder. Creating a symbolic link to the toolchain folder we've already setup is actually enough. If this symbolic link exist, delete it before.
$ ln -s ~/dev/gcc-linaro-version-date-x86_64_aarch64-linux-gnu /PATH/TO/HEXAGON/SDK/tools/linaro
This step will select a qaic executable that fits your distribution.
$ cd /PATH/TO/HEXAGON/SDK/tools/qaic
$ make
This creates the qaic executable in "bin" sub-folder.
A Linux kernel tree with FastRPC support is available here and can be cloned with the following commands:
$ cd ~/dev
$ git clone -b integration-linux-qcomlt https://git.linaro.org/landing-teams/working/qualcomm/kernel.git
$ export ARCH=arm64
$ export CROSS_COMPILE=~/dev/gcc-linaro-7.3.1-2018.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-
$ cd ~/dev/kernel
$ make defconfig
Then use your favorite kernel configuration habit to enable a few more options:
CONFIG_QCOM_FASTRPC=y (Device Drivers -> Misc devices)
For db820c you must enable the Qualcomm Asynchronous Packet Router
CONFIG_QCOM_APR=y (Device Drivers -> SOC (System On Chip) specific Drivers -> Qualcomm SoC drivers)
Then built it:
$ make
You have to copy the modules to the DragonBoard root filesystem. Depending on how you're booting your device it might be easy or a bit more complex.
If the rootfs is located on the internal eMMC you have to install the modules somewhere on the host hard drive:
$ make INSTALL_MOD_PATH=~/dev modules_install
The developer image allows you to remotely connect to the DragonBoard through ssh (using the credentials linaro/linaro) and you can copy the modules to the DragonBoard using scp.
First you need to delete the source and build symlinks in the modules folder (otherwise scp will follow them and copy the build and source trees to the DragonBoard).
$ find ~/dev/lib/modules -type l -print -delete
It's now safe to copy the entire folder to the board rootfs:
$ scp -r ~/dev/lib/modules linaro@DB_IP_ADDR:~/dev
Then ssh to the DragonBoard and move the modules folder:
$ ssh linaro@DB_IP_ADDR
DB $ sudo mv ~/dev/modules/* /lib/modules
It is easier if you boot directly from the SD. Simply mount the SD card on your host system and install the modules directly to the SD card by passing the rootfs mount point.
$ make INSTALL_MOD_PATH=/PATH/TO/MOUNTED/ROOTFS/ modules_install
Now you need to build a boot image for the db410c and boot it using fastboot. You'll need a few more tools to build the boot image.
$ cd ~/dev
$ wget https://snapshots.linaro.org/96boards/dragonboard410c/linaro/debian/latest/initrd.img-4.14.0-qcomlt-arm64
$ git clone git://codeaurora.org/quic/kernel/skales
$ ~/dev/skales/dtbTool -o ~/images/dt.img -s 4096 ~/dev/kernel/arch/arm64/boot/dts/qcom/
$ export CMDLINE="root=/dev/disk/by-partlabel/rootfs rw rootwait console=tty0 console=ttyMSM0,115200n8"
In this example, the rootfs is located on the DragonBoard eMMC. If your rootfs is located on the SD card you must specify 'root=/dev/mmcblk1p9' in the CMDLINE variable above.
$ ~/dev/skales/mkbootimg --kernel ~/dev/kernel/arch/arm64/boot/Image \
--ramdisk ~/dev/initrd.img-4.14.0-qcomlt-arm64 \
--output ~/dev/boot.img \
--dt ~dev/dt.img \
--pagesize 4096 \
--base 0x80000000 \
--cmdline "${CMDLINE}";
Now you have a nice boot image. Boot the DragonBoard in fastboot mode by pressing the vol- button while powering it up. Boot the board with the following command:
$ fastboot boot ~/dev/boot.img
This userspace library is used to communicate with the adsprpc driver. It can be cross-compiled on your host machine or directly on the DragonBoard.
You'll also need to copy it onto the Hexagon SDK so the sample applications use it and not the default stubbed libraries provided by the SDK.
First git clone the repo:
$ cd ~/dev
$ git clone https://git.linaro.org/landing-teams/working/qualcomm/libadsprpc.git
$ cd libadsprpc
Use the autogen.sh script to generate the configure script. You need to install some programs first:
$ sudo apt-get install libtool m4 automake gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
$ ./autogen.sh
Execute the configure script. Use the --host option if you are cross-compiling (you need the Linaro toolchain in your $PATH):
$ ./configure --host=aarch64-linux-gnu
Then build and install:
$ make
$ sudo make install
If you cross-compile from your host machine you obviously need to copy the binaries onto your target device. Once built they are located here:
src/lib/.libs/libadsprpc.so*
src/lib/.libs/libcdsprpc.so*
src/utils/.libs/adsprpcd
src/utils/.libs/cdsprpcd
It's time to hack around with the Hexagon SDK. Copy the library binaries to the SDK for the UbuntuARM target:
$ cp src/lib/.libs/libadsprpc.so* $HEXAGON_SDK_ROOT/libs/common/remote/ship/UbuntuARM_Debug_aarch64/
$ cp src/lib/.libs/libcdsprpc.so* $HEXAGON_SDK_ROOT/libs/common/remote/ship/UbuntuARM_Debug_aarch64/
The easiest way is to install them through apt. If you're running a Debian image obtained from the 96boards website as described above, simply install them on the DragonBoard using apt:
$ sudo apt update
$ sudo apt install rmtfs qrtr libqrtr1
With these packages come the systemd startup script that configure the IPC router and start the remote filesystem service. You can skip the next chapter and Boot the remote DSP.
$ cd ~
$ git clone https://github.com/andersson/qrtr.git
$ cd qrtr
$ make
$ sudo make install
$ cd ~
$ git clone https://github.com/andersson/qmic.git
$ cd qmic
$ make
$ sudo make install
$ cd ~
$ git clone https://github.com/andersson/rmtfs.git
$ cd rmtfs
$ make
$ sudo make install
$ dd if=/dev/zero of=/boot/modem_fs1 bs=1572864 count=1
$ dd if=/dev/zero of=/boot/modem_fs2 bs=1572864 count=1
$ dd if=/dev/zero of=/boot/modem_fsc bs=1024 count=1
$ dd if=/dev/zero of=/boot/modem_fsg bs=1572864 count=1
If the above files were not already present you'll need to reboot the board so the modem is correctly initialized.
You'll have to do so after each boot of your Dragonboard. The Debian packages of these tools already take care of that for your and are started through systemd scripts.
$ sudo qrtr-cfg 1
$ sudo qrtr-ns
$ sudo rmtfs &
Start the remote DSP through its remoteproc device to load DSP firmware.
On db410c:
$ sudo sh -c 'echo start > /sys/devices/platform/soc/4080000.hexagon/remoteproc/remoteproc0/state'
On db820c:
$ sudo sh -c 'echo start > /sys/devices/platform/adsp-pil/remoteproc/remoteproc0/state'
On qcs404 you can choose to boot the aDSP and/or the cDSP.
$ sudo sh -c 'echo start > /sys/devices/platform/remoteproc-adsp/remoteproc/remoteproc0/state'
$ sudo sh -c 'echo start > /sys/devices/platform/remoteproc-cdsp/remoteproc/remoteproc1/state'
On some systems, the remoteproc device index might not be 0. Adapt the above line consequently (i.e .../remoteproc/remoteproc1/state).
On db820c and qcs404 you need to execute the daemon responsible for loading the hexagon code to the DSP.
$ sudo adsprpcd &
If you booted the cDSP on qsc404, launch the cDSP daemon
$ sudo cdsprpcd &
You can test that everything works correctly by using the getserial tool from the Hexagon SDK. This tool queries the remote DSP serial number and prints it.
Please note that getserial only runs on aDSP so it won't work if you boot the cDSP on qcs404.
Copy the getserial executable to the DragonBoard:
$ scp /PATH/TO/HEXAGON/SDK/tools/elfsigner/getserial/UbuntuARM_Release_aarch64/getserial linaro@DB_IP_ADDR:~/dev
And execute it:
$ ssh linaro@DB_IP_ADDR sudo /home/linaro/dev/getserial
If everything works correctly you should get something like:
####################Serial number (see below)###########################
Serial Num : 0xe2afec0
####################Serial number (see above)###########################
If it's not the case, please check:
- Your kernel has support for the fastrpc driver (CONFIG_QCOM_FASTRPC=y)
- For db820c, modem firmware files r1036.1 are installed in /lib/firmware on the DragonBoard
$ source /PATH/TO/HEXAGON/SDK/setup_sdk_env.source
$ cd ~/dev
$ git clone https://git.linaro.org/people/nicolas.dechesne/te/matrix_multi.git
$ cd matrix_multi
$ make V=hexagon_Debug_dynamic_toolv82_v60 tree
$ make V=UbuntuARM_Debug_aarch64 tree
If you wish to run the application on the qcs404 cDSP, use the CDSP_FLAG variable for the Linux target:
$ make V=UbuntuARM_Debug_aarch64 CDSP_FLAG=1 tree
The resulting binaries will be in the following folders:
DSP: hexagon_Debug_dynamic_toolv82_v60/ship
APPS: UbuntuARM_Debug_aarch64/ship
Copy the content to the DragonBoard:
$ ssh linaro@DB_IP_ADDR mkdir /home/linaro/apps /home/linaro/dsp
$ scp matrix_multi/UbuntuARM_Debug_aarch64/ship/* linaro@DB_IP_ADDR:~/apps
For db410c, copy the DSP library:
$ scp matrix_multi/hexagon_Debug_dynamic_toolv82_v60/ship/*.so linaro@DB_IP_ADDR:~/dsp
For db820c, you first need to sign the DSP library and copy it:
$ python $HEXAGON_SDK_ROOT/tools/elfsigner/elfsigner.py -i ./hexagon_Debug_dynamic_toolv82_v60/ship/libmatrix_multi_skel.so
$ scp output/*.so linaro@DB_IP_ADDR:~/dsp
ssh to the DragonBoard and set the library path to the apps and dsp folders:
$ sudo su
$ export ADSP_LIBRARY_PATH=/home/linaro/dsp
$ export LD_LIBRARY_PATH=/home/linaro/apps
Now you're ready to run the example:
$ cd /home/linaro/apps
$ ./matrix_multi 0 10
The matrix_multi example calculates the resulting matrix of multiplying two size x size matrices A and B, where A is a transposing matrix with a single 1 in each column and row and B has random values between 0..size-1 where size is the second parameter passed to the application. Pass 0 as first parameter to execute the multiplication on the remote DSP. Pass 1 to execute it on the application processor.
$ source /PATH/TO/HEXAGON/SDK/setup_sdk_env.source
$ cd /PATH/TO/HEXAGON/SDK/examples/common/calculator
$ make V=hexagon_Debug_dynamic_toolv81_v65 tree
$ make V=UbuntuARM_Debug_aarch64 tree
If you wish to run the application on the qcs404 cDSP, use the CDSP_FLAG variable for the Linux target:
$ make V=hexagon_Debug_dynamic_toolv81_v65 CDSP_FLAG=1 tree
$ make V=UbuntuARM_Debug_aarch64 CDSP_FLAG=1 tree
The resulting binaries will be in the following folders:
DSP: hexagon_Debug_dynamic_toolv81_v65/ship
APPS: UbuntuARM_Debug_aarch64/ship
elfsigner tool takes SoC Serial number as input to generate a testsig, you can get serial number by using getserial
$ python tools/elfsigner/elfsigner.py -t $SERIAL_NUMBER
$ python ./tools/elfsigner/elfsigner.py -i ./examples/common/calculator/ hexagon_Debug_dynamic_toolv81_v65/ship/libcalculator_skel.so
Copy the content to the DragonBoard:
$ ssh linaro@DB_IP_ADDR mkdir /home/linaro/apps /home/linaro/dsp
$ scp matrix_multi/UbuntuARM_Debug_aarch64/ship/* linaro@DB_IP_ADDR:~/apps
ssh to the DragonBoard and set the library path to the apps and dsp folders:
$ sudo su
$ export ADSP_LIBRARY_PATH=/home/linaro/dsp
$ export LD_LIBRARY_PATH=/home/linaro/apps
Now you're ready to run the example:
$ cd /home/linaro/apps
$ ./calculator 0 10
Note: These Steps are not replacement of original guides released as part of Hexagon SDK. These are the steps that I followed to be able to test DB845c CDSP with Hexagon nn.
I have used Hexagon SDK 3.4.2 which has Hexagon NN released as part of SDK package
Step 1: Compile Hexagon NN DSP library:
$ source $HEXAGON_SDK_ROOT/setup_sdk_env.source
$ cd $HEXAGON_SDK_ROOT/libs/hexagon_nn/2.5/
$ make tree VERBOSE=1 CDSP_FLAG=1 V=hexagon_Release_dynamic_toolv82_v65 V65=1
more info on Hexagon nn library at: https://usermanual.wiki/Document/80VB419110HexagonNNLibraryUserGuide.730950702.pdf
Step 2: Download the Tensorflow imagenet Frozen protobuf.
$ curl http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz -o /tmp/inceptionv3.tgz
$ tar xzf /tmp/inceptionv3.tgz -C /tmp/
Then download and Install bazel and build tensorflow More instructions at https://docs.bazel.build/versions/master/install-ubuntu.html I have used Bazel 0.21.0 and TensorFlow 1.13.2 release version.
$ wget https://github.com/bazelbuild/bazel/releases/download/0.21.0/bazel-0.21.0-installer-linux-x86_64.sh
$ wget https://github.com/tensorflow/tensorflow/archive/v1.13.2.tar.gz
$ chmod +x bazel-0.21.0-installer-linux-x86_64.sh
$ sh ./bazel-0.21.0-installer-linux-x86_64.sh --user
$ tar -zxvf v1.13.2.tar.gz
$ cd tensorflow-1.13.2
$ ./configure
Step 3: Build transform_graph tool in tensorflow About tranform_graph https://github.com/tensorflow/tensorflow/blob/master/tensorflow/tools/graph_transforms/README.md#using-the-graph-transform-tool
$ bazel build tensorflow/tools/graph_transforms:transform_graph
Quantize protobuf using Graph Transform Tool
$ bazel-bin/tensorflow/tools/graph_transforms/transform_graph --in_graph=/tmp/classify_image_graph_def.pb --out_graph=/tmp/inception_v3_quantized.pb --inputs="Mul" --outputs='softmax' --transforms='add_default_attributes strip_unused_nodes(type=float, shape="1,299,299,3") remove_nodes(op=Identity, op=CheckNumerics) fold_constants(ignore_errors=true) fold_batch_norms fold_old_batch_norms quantize_weights quantize_nodes fold_constants strip_unused_nodes sort_by_execution_order'
Then convert the quantized protobuf into a C file to be used by graph_app:
$ cd ../../
$ virtualenv -p python2 env2
$ source env2/bin/activate
$ pip install -r environments/req2.txt
$ cd -
$ python ../../scripts/tensorflow_to_hexagon_nn.py /tmp/inception_v3_quantized.pb ./inceptionv3_v1.yaml > iv3.c
Step 4: Build hexgon nn graph_app and define graph via graph_init
$ cp iv3.c $HEXAGON_NN
$ make -C $HEXAGON_NN tree V=UbuntuARM_Debug_aarch64 CDSP_FLAG=1 V65=1 GRAPHINIT="iv3.c"
Step 5: Generate Testsig and sign ibhexagon_nn_skel.so with it.
elfsigner tool takes SoC Serial number as input to generate a testsig, you can get serial number by using getserial
$ python tools/elfsigner/elfsigner.py -t $SERIAL_NUMBER
$ python ./tools/elfsigner/elfsigner.py -i ./libs/hexagon_nn/2.5/hexagon_Release_dynamic_toolv82_v65/ship/libhexagon_nn_skel.so
Step 6: Push files to target
$ scp hexagon_nn/2.5/UbuntuARM_Debug_aarch64/ship/* linaro@DB_IP_ADDR:~/apps
$ scp hexagon_nn/2.5/test/panda_299x299.dat linaro@DB_IP_ADDR:~/apps
$ scp output/testsig*.so linaro@DB_IP_ADDR:~/dsp
$ scp output/libhexagon_nn_skel.so linaro@DB_IP_ADDR:~/dsp
More Info to create new test images:
$ python ../../../examples/hexagon_nn/scripts/img_to_dat.py --root iv3 --input $YOUR_IMAGE_DIRECTORY --size 299 --mean_r 128 --mean_g 128 --mean_b 128 --div_scalar 128 --mul_scalar 128 --byte
#.dat files will be generated in $YOUR_IMAGE_DIRECTORY_b folder
$ scp $YOUR_IMAGE_DIRECTORY_b/*.dat linaro@DB_IP_ADDR:~/apps
Step 7: Run on DB845c
#Build new fastrpc lib
$ git clone -b automake https://git.linaro.org/landing-teams/working/qualcomm/fastrpc.git
$ cd fastrpc
$ ./gitcompile
$ make install
# start cdsp if its not already started.
$ echo start >/sys/devices/platform/remoteproc-cdsp/remoteproc/remoteproc1/state
#Run qrtr services if they have not already started
$ qrtr-cfg 1 && qrtr-ns && rmtfs -v &
#Mount dsp partition
$ mount /dev/disk/by-partlabel/dsp_a /dsp
#export libcdsp path.
$ export ADSP_LIBRARY_PATH=/dsp/cdsp
#copy hexagon dsp library to library path at ADSP_LIBRARY_PATH
$ cp ~/dsp/*.so /dsp/cdsp/
#Start cdsp deamon
$ cdsprpcd&
#run the graph.
$ ~/apps/graph_app --input_to_float 1 --iters 1 ~/apps/panda_299x299.dat
#You should see some thing like this:
Using <./panda_299x299.dat>
filesize=268203 elementsize=1 height=299 width=299 depth=3
Run!
output size=4032
Rank,Softmax,index,string
0,0.954667,169,giant panda
1,0.001520,7,lesser panda
2,0.000926,61,brown bear
3,0.000926,103,ice bear
4,0.000396,82,French bulldog
AppReported: 64300764
Thats it you are done testing tensorflow imagenet model graph using hexagon nn.
This example runs HexagonNN with ImageNet graph on DB845c Dragonboard with live categorizatio from camera input aswell as input images.
https://git.linaro.org/people/srinivas.kandagatla/ImagenetCv.git/
Download from https://developer.qualcomm.com/software/qualcomm-neural-processing-sdk and follow Instructions in https://developer.qualcomm.com/docs/snpe/index.html to setup
Follow below instruction to download Tensorflow Inception model and convert to dlc format. You would need to install tensorflow before you do this as per step 1.
https://developer.qualcomm.com/docs/snpe/model_conv_tensorflow.html
$ ssh linaro@DB_IP_ADDR mkdir /home/linaro/snpe
$ ssh linaro@DB_IP_ADDR mkdir /home/linaro/snpe/dsp /home/linaro/snpe/lib /home/linaro/snpe/bin
$ ssh linaro@DB_IP_ADDR mkdir /home/linaro/inception_v3
$ scp snpe-1.30.0.480/lib/aarch64-linux-gcc4.9/* linaro@DB_IP_ADDR:~/snpe/lib/
$ scp snpe-1.30.0.480/bin/aarch64-linux-gcc4.9/* linaro@DB_IP_ADDR:~/snpe/bin/
$ scp snpe-1.30.0.480/lib/dsp/*.so linaro@DB_IP_ADDR:~/snpe/dsp/
$ scp -r snpe-1.30.0.480/models/inception_v3/data/cropped linaro@DB_IP_ADDR:~/inception_v3/
$ scp snpe-1.30.0.480/models/inception_v3/data/target_raw_list.txt linaro@DB_IP_ADDR:~/inception_v3/
$ scp snpe-1.30.0.480/inception_v3.dlc linaro@DB_IP_ADDR:~/inception_v3/
root@linaro-alip:~# mount /dev/disk/by-partlabel/dsp_a /dsp
root@linaro-alip:~# cp /home/linaro/snpe/dsp/* /dsp/cdsp/
root@linaro-alip:~# export ADSP_LIBRARY_PATH=/dsp/cdsp
root@linaro-alip:~# cdsprpcd&
root@linaro-alip:~# export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/linaro/snpe/lib
root@linaro-alip:~# export PATH=$PATH:/home/linaro/snpe/bin
root@linaro-alip:~# cd /home/linaro/inception_v3
root@linaro-alip:~# LD_PRELOAD=/usr/local/lib/libcdsprpc.so snpe-net-run --use_dsp --container ./inception_v3.dlc --input_list target_raw_list.txt
hello snpe-net-run - fastrpc_apps_user.c:1580: Searching for fastrpc_shell_3 ...hello snpe-net-run - fastrpc_apps_user.c:1688: Successfully created user PD on domain 3 (attrs 0x0)-----------------------------------------------------------
Model String: N/A
SNPE v1.30.0.480
-------------------------------------------------------------------------------
Processing DNN input(s):
cropped/notice_sign.raw
Processing DNN input(s):
cropped/plastic_cup.raw
Processing DNN input(s):
cropped/chairs.raw
Processing DNN input(s):
cropped/handicap_sign.raw
Processing DNN input(s):
cropped/trash_bin.raw
##Check results
root@linaro-alip:~# python /home/linaro/snpe-1.30.0.480/models/inception_v3/scripts/show_inceptionv3_classifications.py -i /home/linaro/snpe-1.30.0.480/models/inception_v3/data/target_raw_list.txt -o /home/linaro/inception_v3/output/ -l /home/linaro/snpe-1.30.0.480/models/inception_v3/tensorflow/imagenet_slim_labels.txt
Classification results
cropped/notice_sign.raw 0.144984 459 brass
cropped/plastic_cup.raw 0.980529 648 measuring cup
cropped/chairs.raw 0.311908 832 studio couch
cropped/handicap_sign.raw 0.382252 920 street sign
cropped/trash_bin.raw 0.746154 413 ashcan
All the patches except below hack should be available in https://git.linaro.org/landing-teams/working/qualcomm/kernel.git/log/?h=integration-linux-qcomlt
Use below hack to make SNPE happy.
diff --git a/arch/arm64/kernel/cpuinfo.c b/arch/arm64/kernel/cpuinfo.c
index 05933c065732..91d996b1ba86 100644
--- a/arch/arm64/kernel/cpuinfo.c
+++ b/arch/arm64/kernel/cpuinfo.c
@@ -177,6 +177,7 @@ static int c_show(struct seq_file *m, void *v)
seq_printf(m, "CPU variant\t: 0x%x\n", MIDR_VARIANT(midr));
seq_printf(m, "CPU part\t: 0x%03x\n", MIDR_PARTNUM(midr));
seq_printf(m, "CPU revision\t: %d\n\n", MIDR_REVISION(midr));
+ seq_printf(m, "Hardware\t: Qualcomm Technologies, Inc SDA845\n");
}
return 0;
Thats it you are done testing Inception v3 model graph using SNPE.
This example runs SNPE with MobileNet SSD graph on DB845c Dragonboard with live boxing from camera input
https://git.linaro.org/people/srinivas.kandagatla/SNPEMobileNetCv.git/