From d14f4d7f773dc258c4ef1639b379867c988850e7 Mon Sep 17 00:00:00 2001 From: hujing Date: Mon, 26 Sep 2022 19:40:05 +0800 Subject: [PATCH 01/12] add bowtie2 config --- .../openeuler-gcc-9.3.0-bowtie2-2.4.5.def | 35 +++++++++++++++++++ container/openeuler-kgcc9-bowtie2-2.4.5.def | 35 +++++++++++++++++++ templates/bowtie2/data.bowtie2.arm.cpu.config | 0 templates/bowtie2/data.bowtie2.x86.cpu.config | 0 4 files changed, 70 insertions(+) create mode 100644 container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def create mode 100644 container/openeuler-kgcc9-bowtie2-2.4.5.def create mode 100644 templates/bowtie2/data.bowtie2.arm.cpu.config create mode 100644 templates/bowtie2/data.bowtie2.x86.cpu.config diff --git a/container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def b/container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def new file mode 100644 index 0000000..ca90930 --- /dev/null +++ b/container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def @@ -0,0 +1,35 @@ +BootStrap: docker +From: openeuler/openeuler + +%environment + source /etc/profile || true + source /etc/profile.d/modules.sh + cd /hpcrunner + source env.sh + +%post + # Install the necessary development environment + yum install -y environment-modules git flex wget vim tar unzip coreutils + # Install base gcc + yum install -y gcc gcc-c++ make cmake libgfortran automake zlib-devel bzip2-devel xz-devel curl-devel openssl-devel + source /etc/profile || true + git config --global http.sslVerify false + git clone https://gitee.com/openeuler/hpcrunner.git -b bowtie2 + cd hpcrunner + source ./init.sh + ./jarvis -i + # Switch config + ./jarvis -use templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config + # downloads bowtie2 + ./jarvis -d + # install dependency + ./jarvis -dp + # build bowtie2 + ./jarvis -b + # run bowtie2 + ./jarvis -r + # clean downloads directory + rm -rf downloads + +%labels + Author Zu \ No newline at end of file diff --git a/container/openeuler-kgcc9-bowtie2-2.4.5.def b/container/openeuler-kgcc9-bowtie2-2.4.5.def new file mode 100644 index 0000000..fb21e36 --- /dev/null +++ b/container/openeuler-kgcc9-bowtie2-2.4.5.def @@ -0,0 +1,35 @@ +BootStrap: docker +From: openeuler/openeuler + +%environment + source /etc/profile || true + source /etc/profile.d/modules.sh + cd /hpcrunner + source env.sh + +%post + # Install the necessary development environment + yum install -y environment-modules git wget unzip make flex tar + # Install base gcc + yum install -y gcc gcc-c++ make cmake automake zlib-devel bzip2-devel xz-devel curl-devel openssl-devel + source /etc/profile || true + git config --global http.sslVerify false + git clone https://gitee.com/hujing2/hpcrunner.git -b bowtie2 + cd hpcrunner + source ./init.sh + ./jarvis -i + # Switch config + ./jarvis -use templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config + # downloads bowtie2 + ./jarvis -d + # install dependency + ./jarvis -dp + # build bowtie2 + ./jarvis -b + # run bowtie2 + ./jarvis -r + # clean downloads directory + rm -rf downloads + +%labels + Author Zu \ No newline at end of file diff --git a/templates/bowtie2/data.bowtie2.arm.cpu.config b/templates/bowtie2/data.bowtie2.arm.cpu.config new file mode 100644 index 0000000..e69de29 diff --git a/templates/bowtie2/data.bowtie2.x86.cpu.config b/templates/bowtie2/data.bowtie2.x86.cpu.config new file mode 100644 index 0000000..e69de29 -- Gitee From 809d5e4392aa84fd3000eddb8c513c9e8a9fbe28 Mon Sep 17 00:00:00 2001 From: hujing Date: Mon, 26 Sep 2022 19:50:47 +0800 Subject: [PATCH 02/12] add bowtie2 config --- templates/bowtie2/{ => 2.4.5}/data.bowtie2.arm.cpu.config | 0 templates/bowtie2/{ => 2.4.5}/data.bowtie2.x86.cpu.config | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename templates/bowtie2/{ => 2.4.5}/data.bowtie2.arm.cpu.config (100%) rename templates/bowtie2/{ => 2.4.5}/data.bowtie2.x86.cpu.config (100%) diff --git a/templates/bowtie2/data.bowtie2.arm.cpu.config b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config similarity index 100% rename from templates/bowtie2/data.bowtie2.arm.cpu.config rename to templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config diff --git a/templates/bowtie2/data.bowtie2.x86.cpu.config b/templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config similarity index 100% rename from templates/bowtie2/data.bowtie2.x86.cpu.config rename to templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config -- Gitee From 1b1534328c0bb8c2874526a61c46b4bb70ced863 Mon Sep 17 00:00:00 2001 From: hujing Date: Mon, 26 Sep 2022 20:13:02 +0800 Subject: [PATCH 03/12] add bowtie2 config --- .../bowtie2/2.4.5/data.bowtie2.arm.cpu.config | 40 +++++++++++++++++++ .../bowtie2/2.4.5/data.bowtie2.x86.cpu.config | 38 ++++++++++++++++++ 2 files changed, 78 insertions(+) diff --git a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config index e69de29..2c035fe 100644 --- a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config +++ b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config @@ -0,0 +1,40 @@ +[SERVER] +11.11.11.11 + +[DOWNLOAD] +bowtie2/2.4.5 https://github.com/BenLangmead/bowtie2/archive/refs/tags/v2.4.5.tar.gz + +[DEPENDENCY] +set -e +set -x +./jarvis -install kgcc/9.3.1 com +module purge +module use ./software/modulefiles +module load kgcc9/9.3.1 +cd ${JARVIS_TMP} +tar -xvf ${JARVIS_DOWNLOAD}/v2.4.5.tar.gz -C ${JARVIS_TMP} +cd ${JARVIS_TMP}/bowtie2-2.4.5 +wget https://github.com/simd-everywhere/simde/archive/refs/tags/v0.7.2.tar.gz +tar -xzf v0.7.2.tar.gz +cp -r simde-0.7.2/simde ./third_party + +[ENV] +module use ./software/modulefiles +module load kgcc9/9.3.1 + +[APP] +app_name = bowtie2 +build_dir = ${JARVIS_TMP}/bowtie2-2.4.5 +binary_dir = ${JARVIS_LIBS}/bowtie2-2.4.5/bin +case_dir = ${JARVIS_TMP}/bowtie2-2.4.5 + +[BUILD] +make -j +make static-libs -j && make STATIC_BUILD=1 -j +mkdir -p ${JARVIS_LIBS}/kgcc9/bowtie2/2.4.5/bin +cp bowtie2* ${JARVIS_LIBS}/kgcc9/bowtie2/2.4.5/bin + +[RUN] +run = make random-test +binary = +nodes = 1 \ No newline at end of file diff --git a/templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config b/templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config index e69de29..47d5e2a 100644 --- a/templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config +++ b/templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config @@ -0,0 +1,38 @@ +[SERVER] +11.11.11.11 + +[DOWNLOAD] +bowtie2/2.4.5 https://github.com/BenLangmead/bowtie2/archive/refs/tags/v2.4.5.tar.gz + +[DEPENDENCY] +set -e +set -x +module purge +./jarvis -install gcc/9.3.0 com +module use ${JARVIS_ROOT}/software/modulefiles +module load gcc9/9.3.0 +cd ${JARVIS_TMP} +tar -xvf ${JARVIS_DOWNLOAD}/v2.4.5.tar.gz -C ${JARVIS_TMP} + +[ENV] +module purge +module use ${JARVIS_ROOT}/software/modulefiles +module load gcc9/9.3.0 + + +[APP] +app_name = bowtie2 +build_dir = ${JARVIS_TMP}/bowtie2-2.4.5 +binary_dir = ${JARVIS_LIBS}/bowtie2-2.4.5/bin +case_dir = ${JARVIS_TMP}/bowtie2-2.4.5 + +[BUILD] +make -j +make static-libs -j && make STATIC_BUILD=1 -j +mkdir -p ${JARVIS_LIBS}/gcc9/bowtie2/2.4.5/bin +cp bowtie2* ${JARVIS_LIBS}/gcc9/bowtie2/2.4.5/bin + +[RUN] +run = make random-test +binary = +nodes = 1 \ No newline at end of file -- Gitee From 5240746682f011a90af2ace7e7e7148c413623b4 Mon Sep 17 00:00:00 2001 From: hujing Date: Mon, 26 Sep 2022 21:43:21 +0800 Subject: [PATCH 04/12] add bowtie2 config --- package/gcc/9.3.0/install.sh | 2 +- templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/package/gcc/9.3.0/install.sh b/package/gcc/9.3.0/install.sh index ce1e008..d851cb8 100644 --- a/package/gcc/9.3.0/install.sh +++ b/package/gcc/9.3.0/install.sh @@ -9,4 +9,4 @@ cd gcc-9.3.0 sed -i "35s/ftp/http/g" ./contrib/download_prerequisites ./contrib/download_prerequisites ./configure --disable-multilib --enable-languages="c,c++,fortran" --prefix=$1 --disable-static --enable-shared -make -j && make install +make -j4 && make install diff --git a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config index 2c035fe..d8f9c46 100644 --- a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config +++ b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config @@ -25,7 +25,7 @@ module load kgcc9/9.3.1 [APP] app_name = bowtie2 build_dir = ${JARVIS_TMP}/bowtie2-2.4.5 -binary_dir = ${JARVIS_LIBS}/bowtie2-2.4.5/bin +binary_dir = case_dir = ${JARVIS_TMP}/bowtie2-2.4.5 [BUILD] -- Gitee From 8953dda5fe340eed7d44ade6f076843f3997c010 Mon Sep 17 00:00:00 2001 From: hujing Date: Tue, 27 Sep 2022 01:37:55 +0800 Subject: [PATCH 05/12] add bowtie2 config and doc --- .DS_Store | Bin 0 -> 6148 bytes doc/.DS_Store | Bin 0 -> 6148 bytes ...25\346\212\245\345\221\212\343\200\213.md" | 684 ++++++++++++++++++ ...15\346\214\207\345\215\227\343\200\213.md" | 260 +++++++ 4 files changed, 944 insertions(+) create mode 100644 .DS_Store create mode 100644 doc/.DS_Store create mode 100644 "doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\346\265\213\350\257\225\346\212\245\345\221\212\343\200\213.md" create mode 100644 "doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..7cbe275046a42350e05301fa3e51caa9dcc81710 GIT binary patch literal 6148 zcmeH~Jr2S!425ml0g0s}V-^m;4I%_5-~tFbB6UFQIXcfj3xyd~=vlJA*s0a_4NWZ~ zdU%d|kwHY(aHH%j%uJDYGRh>k@o~Ffr|E7bw^h;#@Ihw#xlK?3DnJFO02QDD3sN8t z^7Upx&%{Te0#slb3fT9dz>PK8g8u11@DTv)QFg=HX9=)a0j$XuLtMpWxr-|5*!DDnJGPOabkW z=i>n{m1pb6>skGhRa-YW=$9kB{RAMfqj(EMjPm$<_E)<|yX+8FO z$Cjsf`xbz$KK2j562P49h%XO)Js)<%B>Qr}xp&xMz$e~M z`NP4tWKuv1NC7Dz1*E{06{rF`UtIZI9VZ2(z~5KEzYmS>*bB$R_;hfH7JxWoIE?e? zC5X)f#9lZiGD5SY5|e7xVp!4{ZNQd=AjZ#1goGWmf z%ca-<4gH7y|D2?i6p#Y{N&%a#x9b(3RJC>TIIp#h{zUhjZ@L@jLE#YPm>A`l3opm_ ck(7DO=iKjwV`9)54?0ml1Fnlq3jDSLM^~T~8vp/dev/null 2>&1 && echo "wget --no-check-certificate -O-" ) || echo "curl -L") ; \ +$DL http://cpanmin.us | perl - -l /root/hpcrunner/tmp/bowtie2-2.4.5/.tmp App::cpanminus local::lib ; \ +eval `perl -I /root/hpcrunner/tmp/bowtie2-2.4.5/.tmp/lib/perl5 -Mlocal::lib=/root/hpcrunner/tmp/bowtie2-2.4.5/.tmp` ; \ +/root/hpcrunner/tmp/bowtie2-2.4.5/.tmp/bin/cpanm --force File::Which Math::Random Clone Test::Deep Sys::Info ; \ +...... +Created DNA generator + N frac: 0.031 + IUPAC frac: 0.008 + AT/ACGT frac: 0.508 + A/AT frac: 0.526 + C/CG frac: 0.296 +Generating 2 references +Created DNA generator + N frac: 0.031 + IUPAC frac: 0.008 + AT/ACGT frac: 0.508 + A/AT frac: 0.526 + C/CG frac: 0.296 +Generating 2 references + Generated reference 'Sim.pm.1' of untrimmed length 308, trimmed length 276 + Generated reference 'Sim.pm.1' of untrimmed length 308, trimmed length 197 + Generated reference 'Sim.pm.2' of untrimmed length 364, trimmed length 85 +Wrote references to /tmp/Sim.pm.A3VQFNcf.fa + A: 87 + B: 1 + C: 61 + G: 123 + N: 7 + T: 81 + V: 1 +...... +170 reads; of these: + 170 (100.00%) were unpaired; of these: + 170 (100.00%) aligned 0 times + 0 (0.00%) aligned exactly 1 time + 0 (0.00%) aligned >1 times +0.00% overall alignment rate +diff -uw /tmp/Sim.pm.q2WhGHCp.als /tmp/Sim.pm.q2WhGHCp.debug.als +ALSO checking that bowtie2 and bowtie2 -p X w/ X > 1 match up +./bowtie2 --mm --large-index --cp-ival 1 --local --score-min L,7.34249013574406,1.76331087522275 --rfg 19.2968780660232,11.9325479307522 --cp-min 2 -q -p 3 -x /tmp/Sim.pm.q2WhGHCp /tmp/Sim.pm.q2WhGHCp_1.fastq | grep -v '^@PG' > /tmp/Sim.pm.q2WhGHCp.px.als +Warning: skipping read '5' because length (1) <= # seed mismatches (0) +Warning: skipping read '5' because it was < 2 characters long +Warning: skipping read '41' because length (1) <= # seed mismatches (0) +Warning: skipping read '41' because it was < 2 characters long +Warning: skipping read '157' because length (1) <= # seed mismatches (0) +Warning: skipping read '157' because it was < 2 characters long +170 reads; of these: + 170 (100.00%) were unpaired; of these: + 170 (100.00%) aligned 0 times + 0 (0.00%) aligned exactly 1 time + 0 (0.00%) aligned >1 times +0.00% overall alignment rate +sort -k 1,1 -n -k 2,2 -k 3,3 -k 4,4 < /tmp/Sim.pm.q2WhGHCp.px.als | grep -v '^@PG' > /tmp/Sim.pm.q2WhGHCp.px.als.sorted +sort -k 1,1 -n -k 2,2 -k 3,3 -k 4,4 < /tmp/Sim.pm.q2WhGHCp.debug.als | grep -v '^@PG' > /tmp/Sim.pm.q2WhGHCp.debug.als.sorted +diff -uw /tmp/Sim.pm.q2WhGHCp.debug.als.sorted /tmp/Sim.pm.q2WhGHCp.px.als.sorted +PASSED +``` + +由于测试输出结果过长,这里只显示了部分,感兴趣的同学可以自己安装进行测试。 + +## 3.性能测试 + +### 3.1.测试平台信息对比 + +| | arm信息 | x86信息 | +| -------- | --------------------------------------------- | --------------------------- | +| 操作系统 | openEuler 20.09 | openEuler 20.09 | +| 内核版本 | 4.19.90-2110.8.0.0119.oe1.aarch64 | 4.19.90-2003.4.0.0036.oe1.x86_64 | + +### 3.2.测试软件环境信息对比 + +| | arm信息 | x86信息 | +| ----- | ------------- | --------- | +| gcc | kgcc 9.3.1 | gcc 9.3.0 | +| bowtie2 | 2.4.5 | 2.4.5 | + +### 3.3.测试硬件性能信息对比 + +| | arm信息 | x86信息 | +| ------ | ----------- | ---------- | +| cpu | Kunpeng 920 | Intel(R) Xeon(R) Gold 6278C| +| 核心数 | 8 | 8 | +| 内存 | 16 GB | 16 GB | +| 磁盘io | 1.3 GB/s | 1.3 MB/s | +| 虚拟化 | KVM | KVM | + +### 3.4.单线程 +单线程运行测试时间对比(五次运行取平均值) +| | arm | x86 | +| -------------- | -------- | -------- | +| 实际CPU时间 | 3m2.592s | 1m46.784s | +| 用户时间 | 2m26.153s | 0m57.053s | + +### 3.5.多线程 + +多线程运行测试时间对比(五次运行取平均值) + +| | arm | x86 | +| ----------- | ---------- | --------- | +| 线程数 | 4 | 4 | +| 实际CPU时间 | 0m47.075s | 0m35.997s | +| 用户时间 | 0m7.956s | 0m16.749s | + +arm多线程时间耗费数据表: + +| 线程 | 1 | 2 | 4 | 8 | +| :------------ | -------- | ------- | -------- | ------- | +| 用户时间(s) | 182.592 | 172.340 | 116.716 | 180.501 | +| 用户态时间(s) | 146.153 | 218.942 | 272.470 | 837.371 | +| 内核态时间(s) | 13.765 | 26.512 | 53.088 | 96.164 | + +x86多线程时间耗费数据表: +| 线程 | 1 | 2 | 4 | 8 | +| :------------ | -------- | ------- | -------- | ------- | +| 用户时间(s) | 106.784 | 104.843 | 72.823 | 85.073 | +| 用户态时间(s) | 57.053 | 110.375 | 220.173 | 380.683 | +| 内核态时间(s) | 19.753 | 41.605 | 63.530 | 98.340 | + +测试效果取决网络的好坏,因此上述数据可以不做参考,但是从数据不难看出线程为4效果较好 + +## 4.精度测试 + +### 4.1.所选测试案例 + +scripts/sim下的run.pl文件 + +```perl +use strict; +use warnings; +use Getopt::Long; +use FindBin qw($Bin); +use lib "$Bin"; +use lib "$Bin/contrib"; +use Sim; +use ForkManager; + +# Simulator configuration +our %conf = ( + bowtie2_build => "bowtie2-build", + bowtie2 => "bowtie2", + bowtie2_build_debug => "bowtie2-build --debug", + bowtie2_debug => "bowtie2 --debug", + tempdir => "/tmp", + no_color => 1, + small => 1 +); + +# Number of parallel processes to use +my $cpus = 1; + +my $usage = qq! +run.pl [options*] + +Options: + + --bowtie2 Path to bowtie2 release binary + --bowtie2-debug Path to bowtie2 debug binary + --bowtie2-build Path to bowtie2-build release binary + --bowtie2-build-debug Path to bowtie2-build debug binary + --tempdir Put temporary files here + --cases Each thread runs around cases (def: 5) + --cpus / -p Run test cases in threads at once + --maxreads Handle at most reads per case + --numrefs Generate refs per case + --die-with-child Kill parent as soon as 1 child dies + --no-die-with-child Don\'t kill parent as soon as 1 child dies + --small Make small test cases + --help Print this usage message + +!; + +my $help = 0; +my $ncases = 5; +my $dieWithChild = 1; + +GetOptions( + "bowtie2=s" => \$conf{bowtie2}, + "bowtie2-build=s" => \$conf{bowtie2_build}, + "tempdir|tmpdir=s" => \$conf{tempdir}, + "cases-per-thread=i" => \$ncases, + "small" => \$conf{small}, + "large" => sub { $conf{small} = 0 }, + "no-paired" => \$conf{no_paired}, + "color" => sub { $conf{no_color} = 0 }, + "no-color" => \$conf{no_color}, + "help" => \$help, + "die-with-child" => \$dieWithChild, + "no-die-with-child" => sub { $dieWithChild = 0 }, + "p|cpus=i" => \$cpus, + "u|qupto|maxreads=i" => \$conf{maxreads}, + "numrefs|num-refs=i" => \$conf{numrefs}, +) || die "Bad options;"; + +if($help) { + print $usage; + exit 0; +} + +my $sim = Sim->new(); +my $pm = new Parallel::ForkManager($cpus); + +# Callback for when a child finishes so we can get its exit code +my @childFailed = (); +my @childFailedPid = (); + +$pm->run_on_finish(sub { + my ($pid, $exit_code, $ident) = @_; + if($exit_code != 0) { + push @childFailed, $exit_code; + push @childFailedPid, $pid; + !$dieWithChild || die "Dying with child with PID $pid"; + } +}); + +my $totcases = $ncases * $cpus; +for(1..$totcases) { + my $childPid = $pm->start; + if($childPid != 0) { + next; # spawn the next child + } + $sim->nextCase(\%conf); + $pm->finish; +} +$pm->wait_all_children; +for(@childFailedPid) { + print STDERR "Error message from child with pid $_:\n"; + my $fn = ".run.pl.child.$_"; + if(open(ER, $fn)) { + print STDERR "---------\n"; + while() { + print STDERR $_; + } + print STDERR "---------\n"; + close(ER); + } else { + print STDERR "(could not open $fn)\n"; + } +} +print STDERR "PASSED\n"; +``` + +### 4.2.获取对比数据 + +arm 运行结果(部分) + +```bash +156 reads; of these: + 156 (100.00%) were paired; of these: + 156 (100.00%) aligned concordantly 0 times + 0 (0.00%) aligned concordantly exactly 1 time + 0 (0.00%) aligned concordantly >1 times + ---- + 156 pairs aligned concordantly 0 times; of these: + 0 (0.00%) aligned discordantly 1 time + ---- + 156 pairs aligned 0 times concordantly or discordantly; of these: + 312 mates make up the pairs; of these: + 293 (93.91%) aligned 0 times + 16 (5.17%) aligned exactly 1 time + 3 (0.92%) aligned >1 times +6.09% overall alignment rate +diff -uw /tmp/Sim.pm.Sx0_YrOH.debug.als /tmp/Sim.pm.Sx0_YrOH.px.reord.als +PASSED +``` + +### 4.3.测试总结 +从arm输出结果可以看出测试通过,误差为0.92%,所有运算结果偏差在1%以内,偏差较小。 \ No newline at end of file diff --git "a/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" "b/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" new file mode 100644 index 0000000..b7e6340 --- /dev/null +++ "b/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" @@ -0,0 +1,260 @@ +# 《基于openEuler的bowtie2软件移植指南》 + +## 1.介绍 + +- Bowtie2是将测序reads与长参考序列比对工具(适用于将长度大约为50到100或1000字符的reads与相对较长的基因组,如哺乳动物基因组,进行比对)。通常是比较基因组学(包括识别变体(variation calling)、ChIP-seq、RNA-seq和BS-seq)管道的第一步。它可以处理非常长的读数(即10s或100s的千字节),但它针对近期测序仪产生的读数长度和误差模式进行了优化,如Illumina HiSeq 2000、Roche 454和Ion Torrent仪器。 + +- Bowtie2使用FM索引(基于Burrows-Wheeler Transform或BWT)对基因组进行索引,以此来保持其占用较小内存。对于人类基因组来说,内存占用在3.2G左右。 + +- 官网地址:http://bowtie-bio.sourceforge.net/bowtie2/manual.shtml + +- GITHUB托管地址:https://github.com/BenLangmead/bowtie2 + +- 特征: + + - 支持间隔 + - 局部和双端对齐模式 + - 可以同时使用多个处理器来极大的提升比对速度 + +## 2.环境要求 + +- 操作系统:openeuler arm/x86 (本文档以 x86 架构为例) + +## 3.配置编译环境 + +配置环境指导,手动进行配置依赖环境。 + +### 3.1.环境总览 + +- 编译器:gcc + +- 其他类库:`Cmake` + +- 具体版本和下载地址如下 + +| 名称 | 版本 | 软件下载地址 | +| -------- | ------ | ---------------------------------------------------------------------------------------------- | +| gcc | 9.3.0 | | +| CMake | 3.23.1 | | + +### 3.2.创建文件夹 + +```bash +mkdir -p $HOME/build +mkdir -p $HOME/install +mkdir -p $HOME/tmp +``` + +### 3.3.安装预设 + +设置环境变量,方便修改自定义安装目录 + +- 编译目录为 $HOME/build , 根据实际情况进行修改 +- 软件安装目录为 $HOME/install , 根据实际情况进行修改 +- 下载目录为 $HOME/tmp , 根据实际情况进行修改 + +```bash +#为了方便自定义软件安装目录 +#环境变量DEP_INSTALL_DIR将在后文中作为软件安装目录的根目录 +export DEP_INSTALL_DIR=$HOME/install +#环境变量DEP_BUILD_DIR将在后文中作为编译的根目录 +export DEP_BUILD_DIR=$HOME/build +#环境变量DEP_DOWNLOAD_DIR将在后文中作为下载文件的保存目录 +export DEP_DOWNLOAD_DIR=$HOME/tmp + +#注: 以上变量只在一次会话中有效。如果中途断开ssh会话,则在后续的安装过程中不会生效,需要重新运行 +``` + +### 3.4.安装环境依赖和gcc编译器 + +```bash +#环境依赖 +yum -y install gcc gcc-c++ wget tar libatomic + +#安装gcc编译器 +wget -P $DEP_DOWNLOAD_DIR https://ftp.gnu.org/gnu/gcc/gcc-9.3.0/gcc-9.3.0.tar.gz +tar -xf $DEP_DOWNLOAD_DIR/gcc-9.3.0.tar.gz -C $DEP_INSTALL_DIR +sed -i "35s/ftp/http/g" ./contrib/download_prerequisites +./contrib/download_prerequisites +./configure --disable-multilib --enable-languages="c,c++,fortran" --prefix=$1 --disable-static --enable-shared +make -j && make install +#设置环境变量 +echo "export PATH=$DEP_INSTALL_DIR/gcc-9.3.0/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +export CC=`which gcc` +export CXX=`which g++` +``` + +### 3.5.下载并编译`CMake` + +```bash +# 下载CMake +wget https://github.com/Kitware/CMake/releases/download/v3.23.1/cmake-3.23.1-linux-x86_64.tar.gz -O $DEP_DOWNLOAD_DIR/cmake-3.23.1.tar.gz +tar -xvf $DEP_DOWNLOAD_DIR/cmake-3.23.1-linux-x86_64.tar.gz -C $DEP_INSTALL_DIR/cmake --strip-components=1 +echo "export PATH=$DEP_INSTALL_DIR/cmake/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +``` + +## 4.编译bowtie2 + +### 4.1.下载并编译bowtie2 + +获取bowtie2软件源码并解压文件 +```bash +# 下载源码文件 +wget https://github.com/BenLangmead/bowtie2/archive/refs/tags/v2.4.5.tar.gz +# 解压源码文件 +tar -xvf $DEP_DOWNLOAD_DIR/v2.4.5.tar.gz -C $DEP_BUILD_DIR +cd $DEP_BUILD_DIR/bowtie2-2.4.5 +make -j +make static-libs -j && make STATIC_BUILD=1 -j +``` + +### 4.2. 运行测试文件 + +运行bowtie2项目测试文件 + +```bash +cd $DEP_BUILD_DIR/bowtie2-2.4.5 +make random-test +``` + +## 附A:使用hpcrunner进行一键安装BOWTIE2 + +推荐使用hpcrunner进行安装BOWTIE2 + +### 1.克隆仓库 + +```bash +git clone https://gitee.com/openeuler/hpcrunner.git +``` + +## 2.初始化hpcrunner 和 安装必要软件包 + +初始化项目助手 + +```bash +cd hpcrunner +source init.sh +``` + +安装必要软件包 + +**arm / x86 需要的软件包不同,根据实际环境进行选择** + +```bash +# arm +yum install -y environment-odules git wget unzip make flex tar +# x86 +yum install -y environment-modules git wget unzip make flex tar +yum install -y gcc gcc-c++ gcc-gfortran glibc-devel libgfortran +yum install -y tcsh tcl lsof tk bc +``` + +### 3.选择平台对应配置文件 + +- arm平台的配置文件为 `templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config` + + ```bash + ./jarvis -use templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config + ``` + +- x86 平台的配置文件为 `templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config` + + ```bash + ./jarvis -use templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config + ``` + +### 4.下载bowtie2源码 + +```bash +./jarvis -d +``` + +### 5.一键配置依赖环境 + +```bash +./jarvis -dp +``` + +### 6.一键进行编译 + +```bash +./jarvis -b +``` + +### 7.一键进行运行测试 + +```bash +./jarvis -r +``` + +## 附B:使用singularity运行容器 + +### 使用教程 + +### 下载容器镜像 + +通过链接下载: +[百度云盘](https://pan.baidu.com/s/1UjHiv6DN_oOVXcuohP5Uqg?pwd=vxit) + +或者扫码下载: + +![百度云](data:image/png;base64,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) + +#### 1.安装singularity + +安装singularity, + +具体步骤如下 + +```bash +mkdir -p ~/install +mkdir -p ~/build + +#安装编译所需依赖 +yum -y install libatomic libstdc++ libstdc++-devel libseccomp-devel glib2-devel gcc squashfs-tools tar + +#安装bisheng编译器 +cd ~/build +wget https://mirrors.huaweicloud.com/kunpeng/archive/compiler/bisheng_compiler/bisheng-compiler-2.1.0-aarch64-linux.tar.gz +tar -C ~/install -xf bisheng-compiler-2.1.0-aarch64-linux.tar.gz +echo "export PATH=$HOME/install/bisheng-compiler-2.1.0-aarch64-linux/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +export CC=`which clang` +export CXX=`which clang++` + +#安装go编译器 +cd ~/build +wget https://go.dev/dl/go1.19.linux-arm64.tar.gz +tar -C ~/install -xf go1.19.linux-arm64.tar.gz +echo "export PATH=$HOME/install/go/bin:$PATH" >> ~/.bashrc && source ~/.bashrc + +#安装singularity +cd ~/build +wget https://github.com/sylabs/singularity/releases/download/v3.10.2/singularity-ce-3.10.2.tar.gz +tar -xf singularity-ce-3.10.2.tar.gz +cd singularity-ce-3.10.2 +./mconfig --prefix=$HOME/install/singularity +make -C ./builddir +make -C ./builddir install +echo "export PATH=$HOME/install/singularity/bin:$PATH" >> ~/.bashrc && source ~/.bashrc +``` + +#### 2.构建镜像 + +```shell +# x86 +singularity build ./name-of-image.sif openeuler-gcc-9.3.0-bowtie2-2.4.5.def +# arm +singularity build ./name-of-image.sif openeuler-kgcc-9.3.1-bowtie2-2.4.5.def +# 转换为沙盒 +singularity build --sandbox image-sandbox name-of-image.sif +``` + +#### 3.在沙盒中运行 + +```shell +#进入沙盒 +singularity shell -w image-sandbox +#在沙盒中运行内置的测试案例 +cd /hpcrunner +./jarvis -r +``` \ No newline at end of file -- Gitee From 87d7654b2b6dcfc5381941a1813c28996eb27e83 Mon Sep 17 00:00:00 2001 From: hujing Date: Tue, 27 Sep 2022 02:52:10 +0800 Subject: [PATCH 06/12] add bowtie2 config and doc --- test/test-bowtie2.sh | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 test/test-bowtie2.sh diff --git a/test/test-bowtie2.sh b/test/test-bowtie2.sh new file mode 100644 index 0000000..ce74a42 --- /dev/null +++ b/test/test-bowtie2.sh @@ -0,0 +1,16 @@ +#!/bin/bash +cd .. +# release bowtie2 src code +rm -rf tmp/bowtie2-2.4.5 +# copy templates +cp -rf templates/bowtie2/2.4.5/data.bowtie2.x86.cpu.config ./ +# switch to config +./jarvis -use data.bowtie2.x86.cpu.config +# download bowtie2 src code +./jarvis -d +# install dependency +./jarvis -dp +# build +./jarvis -b +# run +./jarvis -r \ No newline at end of file -- Gitee From 9f93cd0621d447d4eeea88b3ade13fecfafc6086 Mon Sep 17 00:00:00 2001 From: hujing Date: Tue, 27 Sep 2022 02:52:59 +0800 Subject: [PATCH 07/12] add bowtie2 config and doc --- package/gcc/9.3.0/install.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package/gcc/9.3.0/install.sh b/package/gcc/9.3.0/install.sh index d851cb8..ce1e008 100644 --- a/package/gcc/9.3.0/install.sh +++ b/package/gcc/9.3.0/install.sh @@ -9,4 +9,4 @@ cd gcc-9.3.0 sed -i "35s/ftp/http/g" ./contrib/download_prerequisites ./contrib/download_prerequisites ./configure --disable-multilib --enable-languages="c,c++,fortran" --prefix=$1 --disable-static --enable-shared -make -j4 && make install +make -j && make install -- Gitee From b6d1d62c33ff26a353aa148fc0cb6f2e279d07fa Mon Sep 17 00:00:00 2001 From: hujing Date: Wed, 28 Sep 2022 19:42:24 +0800 Subject: [PATCH 08/12] updata bisheng config --- ...tie2-2.4.5.def => openeuler-bisheng2-bowtie2-2.4.5.def} | 0 templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config | 7 ++++--- 2 files changed, 4 insertions(+), 3 deletions(-) rename container/{openeuler-kgcc9-bowtie2-2.4.5.def => openeuler-bisheng2-bowtie2-2.4.5.def} (100%) diff --git a/container/openeuler-kgcc9-bowtie2-2.4.5.def b/container/openeuler-bisheng2-bowtie2-2.4.5.def similarity index 100% rename from container/openeuler-kgcc9-bowtie2-2.4.5.def rename to container/openeuler-bisheng2-bowtie2-2.4.5.def diff --git a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config index d8f9c46..c5881eb 100644 --- a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config +++ b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config @@ -7,20 +7,21 @@ bowtie2/2.4.5 https://github.com/BenLangmead/bowtie2/archive/refs/tags/v2.4.5.ta [DEPENDENCY] set -e set -x -./jarvis -install kgcc/9.3.1 com +./jarvis -install bisheng/2.1.0 com module purge module use ./software/modulefiles -module load kgcc9/9.3.1 +module load bisheng2/2.1.0 cd ${JARVIS_TMP} tar -xvf ${JARVIS_DOWNLOAD}/v2.4.5.tar.gz -C ${JARVIS_TMP} cd ${JARVIS_TMP}/bowtie2-2.4.5 +sed -i 's/\CXXFLAGS += -std=c++11/\CXXFLAGS += -std=c++11 -stdlib=libc++/g' Makefile wget https://github.com/simd-everywhere/simde/archive/refs/tags/v0.7.2.tar.gz tar -xzf v0.7.2.tar.gz cp -r simde-0.7.2/simde ./third_party [ENV] module use ./software/modulefiles -module load kgcc9/9.3.1 +module load bisheng2/2.1.0 [APP] app_name = bowtie2 -- Gitee From b9b39efaf4c1454be1d6dc120158b7d51b000181 Mon Sep 17 00:00:00 2001 From: hujing Date: Wed, 28 Sep 2022 19:59:25 +0800 Subject: [PATCH 09/12] updata bisheng config --- templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config | 3 +++ 1 file changed, 3 insertions(+) diff --git a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config index c5881eb..1e2aa1e 100644 --- a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config +++ b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config @@ -22,6 +22,9 @@ cp -r simde-0.7.2/simde ./third_party [ENV] module use ./software/modulefiles module load bisheng2/2.1.0 +export CC=`which clang` +export CXX=`which clang++` +export FC=`which flang` [APP] app_name = bowtie2 -- Gitee From a1f09beada938ee5c0cba311401d1bf4cf4fcff5 Mon Sep 17 00:00:00 2001 From: hujing Date: Wed, 28 Sep 2022 20:37:58 +0800 Subject: [PATCH 10/12] updata bisheng config --- container/openeuler-bisheng2-bowtie2-2.4.5.def | 2 +- container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/container/openeuler-bisheng2-bowtie2-2.4.5.def b/container/openeuler-bisheng2-bowtie2-2.4.5.def index fb21e36..8785178 100644 --- a/container/openeuler-bisheng2-bowtie2-2.4.5.def +++ b/container/openeuler-bisheng2-bowtie2-2.4.5.def @@ -14,7 +14,7 @@ From: openeuler/openeuler yum install -y gcc gcc-c++ make cmake automake zlib-devel bzip2-devel xz-devel curl-devel openssl-devel source /etc/profile || true git config --global http.sslVerify false - git clone https://gitee.com/hujing2/hpcrunner.git -b bowtie2 + git clone https://gitee.com/openeuler/hpcrunner.git cd hpcrunner source ./init.sh ./jarvis -i diff --git a/container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def b/container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def index ca90930..0c6b191 100644 --- a/container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def +++ b/container/openeuler-gcc-9.3.0-bowtie2-2.4.5.def @@ -14,7 +14,7 @@ From: openeuler/openeuler yum install -y gcc gcc-c++ make cmake libgfortran automake zlib-devel bzip2-devel xz-devel curl-devel openssl-devel source /etc/profile || true git config --global http.sslVerify false - git clone https://gitee.com/openeuler/hpcrunner.git -b bowtie2 + git clone https://gitee.com/openeuler/hpcrunner.git cd hpcrunner source ./init.sh ./jarvis -i -- Gitee From e90c1cf4bc392342bc3ee4fc1b5866b302652924 Mon Sep 17 00:00:00 2001 From: hujing Date: Wed, 28 Sep 2022 21:00:40 +0800 Subject: [PATCH 11/12] updata bisheng config --- ...273\346\244\215\346\214\207\345\215\227\343\200\213.md" | 7 ++++--- templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config | 4 ++-- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git "a/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" "b/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" index b7e6340..7544c84 100644 --- "a/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" +++ "b/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" @@ -194,11 +194,12 @@ yum install -y tcsh tcl lsof tk bc ### 下载容器镜像 通过链接下载: -[百度云盘](https://pan.baidu.com/s/1UjHiv6DN_oOVXcuohP5Uqg?pwd=vxit) +[百度云盘](https://pan.baidu.com/s/1H1gfA1gC18A7z6EDux4dEA) +提取码: 7fla 或者扫码下载: -![百度云](data:image/png;base64,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) +![百度云](data:image/jpeg;base64,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) #### 1.安装singularity @@ -244,7 +245,7 @@ echo "export PATH=$HOME/install/singularity/bin:$PATH" >> ~/.bashrc && source ~/ # x86 singularity build ./name-of-image.sif openeuler-gcc-9.3.0-bowtie2-2.4.5.def # arm -singularity build ./name-of-image.sif openeuler-kgcc-9.3.1-bowtie2-2.4.5.def +singularity build ./name-of-image.sif openeuler-bisheng2-9.3.1-bowtie2-2.4.5.def # 转换为沙盒 singularity build --sandbox image-sandbox name-of-image.sif ``` diff --git a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config index 1e2aa1e..716384f 100644 --- a/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config +++ b/templates/bowtie2/2.4.5/data.bowtie2.arm.cpu.config @@ -35,8 +35,8 @@ case_dir = ${JARVIS_TMP}/bowtie2-2.4.5 [BUILD] make -j make static-libs -j && make STATIC_BUILD=1 -j -mkdir -p ${JARVIS_LIBS}/kgcc9/bowtie2/2.4.5/bin -cp bowtie2* ${JARVIS_LIBS}/kgcc9/bowtie2/2.4.5/bin +mkdir -p ${JARVIS_LIBS}/bisheng2/bowtie2/2.4.5/bin +cp bowtie2* ${JARVIS_LIBS}/bisheng2/bowtie2/2.4.5/bin [RUN] run = make random-test -- Gitee From 492b46439b57c4ee74b6fbdbd701e6b726c0ca87 Mon Sep 17 00:00:00 2001 From: hujing Date: Wed, 28 Sep 2022 21:07:20 +0800 Subject: [PATCH 12/12] updata bisheng config --- ...\273\346\244\215\346\214\207\345\215\227\343\200\213.md" | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git "a/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" "b/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" index 7544c84..da7c0c0 100644 --- "a/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" +++ "b/doc/bowtie2/\343\200\212\345\237\272\344\272\216openEuler\347\232\204bowtie2\350\275\257\344\273\266\347\247\273\346\244\215\346\214\207\345\215\227\343\200\213.md" @@ -194,12 +194,12 @@ yum install -y tcsh tcl lsof tk bc ### 下载容器镜像 通过链接下载: -[百度云盘](https://pan.baidu.com/s/1H1gfA1gC18A7z6EDux4dEA) -提取码: 7fla +[百度云盘](https://pan.baidu.com/s/1dh_Ns4HVR4KJ6J_yMfrh2A) +提取码: hjrf 或者扫码下载: -![百度云](data:image/jpeg;base64,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) +![百度云](data:image/jpeg;base64,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) #### 1.安装singularity -- Gitee