首页 > 其他分享 >fio

fio

时间：2024-04-24 22:12:05浏览次数：14  
标签：rw th 0.00 await IO fio 0.0%

概念

  • IOPS：Input/Output Per Second，每秒读/写次数，单位为次(计数)
  • 延迟：是指完成一次IO请求所需的时间。延迟是关注存储性能时最重要的指标。
  • TPUT： 带宽也叫吞吐量，每秒的读写数据量，单位为MB/S。
  • 同步IO：同步就是在一个功能调用时，在没有得到结果之前，该调用就不返回。当IO读写过程中阻塞时，用户线程就会阻塞。
  • 异步IO：异步是由内核发起读写，用户线程只需要关注IO完成后的回调，不需要参与到具体的IO之中，当IO读写阻塞时，用户线程并不阻塞，在并发测试中可以转到下一个读写,当IO队列深度大于1时可以发挥并发读写优势。
  • 随机IO：假设我们所需要的数据是随机分散在磁盘的不同页的不同扇区中的，那么找到相应的数据需要等到磁臂(寻址作用)旋转到指定的页，然后再寻找到对应的扇区，才能找到我们所需要的一块数据，下次在寻找其他的数据还需要重复此过程。主要作用是针对零碎文件(病毒扫描、启动程序等)任务。这时我们主要关注IOPS指标。
  • 顺序IO：假设我们已经找到了第一块数据，并且其他所需的数据就在这一块数据后边，那么就不需要重新寻址，可以依次拿到我们所需的数据。这个模式可显示最高的吞吐量。主要是针对的大容量文件读写文件性能，这时我们主要关注带宽指标。
  • I0队列深度：IO驱动层一次向磁盘传递的IO请求个数。也就是同时处理多少个IO。拥有队列是有益的，因为队列中的请求可以以优化的方式（通常是并行方式）提交给存储子系统。

fio

  • fio常用参数
filename=/dev/emcpowerb　      支持文件系统或者裸设备，-filename=/dev/sda
direct=1                       测试过程绕过机器自带的buffer，使测试结果更真实
rw=randwread                   测试随机读的I/O
rw=randwrite                   测试随机写的I/O
rw=randrw                      测试随机混合写和读的I/O
rw=read                        测试顺序读的I/O
rw=write                       测试顺序写的I/O
rw=rw                          测试顺序混合写和读的I/O
bs=4k                          单次io的块文件大小为4k
bsrange=512-2048               同上，提定数据块的大小范围
size=5g                        本次的测试文件大小为5g，以每次4k的io进行测试
numjobs=30                     本次的测试线程为30
runtime=1000                   测试时间为1000秒，如果不写则一直将5g文件分4k每次写完为止
ioengine=psync                 io引擎使用pync方式（同步I），如果要使用libaio引擎, 需要yum install libaio-devel包
rwmixwrite=30                  在混合读写的模式下，写占30%
group_reporting                关于显示结果的，汇总每个进程的信息
lockmem=1g                     只使用1g内存进行测试
zero_buffers                   用0初始化系统buffer。
nrfiles=8                      每个进程生成文件的数量。
  • 磁盘读写常用测试点
1. Read=100% Ramdon=100% rw=randread (100%随机读)
2. Read=100% Sequence=100% rw=read （100%顺序读）
3. Write=100% Sequence=100% rw=write （100%顺序写）
4. Write=100% Ramdon=100% rw=randwrite （100%随机写）
5. Read=70% Sequence=100% rw=rw, rwmixread=70, rwmixwrite=30  （70%顺序读，30%顺序写）
6. Read=70% Ramdon=100% rw=randrw, rwmixread=70, rwmixwrite=30 (70%随机读，30%随机写)
  • Fio输出结果说明
io               执行了多少M的IO
bw               平均IO带宽
iops             IOPS
runt             线程运行时间
slat             提交延迟  （stdev指标准差）
clat             完成延迟
lat              响应时间
bw               带宽
cpu              利用率
IO depths        io队列
IO submit        单个IO提交要提交的IO数
IO complete      与上面的提交编号类似，但用于完成。
IO issued        发出的读/写请求的数量，以及其中有多少是短的。
IO latencies     IO完延迟的分布
io               总共执行了多少size的IO
aggrb            group总带宽
minb             最小平均带宽.
maxb             最大平均带宽.
mint             group中线程的最短运行时间.
maxt             group中线程的最长运行时间.
ios              所有group总共执行的IO数.
merge            总共发生的IO合并数.
ticks            我们保持磁盘繁忙的ticks数。
io_queue         花费在队列上的总共时间.
util             磁盘利用率
  • 重点关注参数
IOPS: 每秒的输入输出量(或读写次数)，是衡量磁盘性能的主要指标之一；
Bw: 带宽；
slat 表示fio 提交到内核某个I/O的延迟；
clat 表示fio 内核完成某个I/O的延迟；
lat 表示从fio将请求提交给内核，再到内核完成这个I/O为止所需要的时间；
关系是 lat = slat + clat
usr：表示用户空间进程；
sys：表示内核空间进程；

测试

  1. 顺序读
    fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest

  2. 随机写
    fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest

  3. 顺序写
    fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest

  4. 混合随机读写
    fio -filename=/dev/sdb1 -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=mytest -ioscheduler=noop

  • 顺序读

bs 单次io的块文件大小，我们建议可以设置为数据库的块或页大小，在真实的环境中或以调大size
我们需要得点关注的是IOPS ：3317 以及BW IO带宽是：13.0MiB/s
read: IOPS=3317, BW=13.0MiB/s (13.6MB/s)(2332MiB/180001msec)

fio -filename=/dev/sda1 -direct=1 -iodepth= 1 -rw=read -ioengine=psync -bs=4k -size=1000G -numjobs=50 -runtime=180 -group_reporting -name=sqe_100read_4k

[root@s2ahumysqlpg01 tmp]# fio -filename=/tmp/read.dat -direct=1 -iodepth 1  -rw=read -ioengine=psync -bs=4k -size=4G -numjobs=1 -runtime=180 -group_reporting -name=sqe_100read_4k
sqe_100read_4k: (g=0): rw=read, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=psync, iodepth=1
fio-3.29
Starting 1 process
sqe_100read_4k: Laying out IO file (1 file / 4096MiB)
Jobs: 1 (f=1): [R(1)][100.0%][r=8372KiB/s][r=2093 IOPS][eta 00m:00s]ta 00m:56s]
sqe_100read_4k: (groupid=0, jobs=1): err= 0: pid=5685: Fri Mar  4 17:42:10 2022
  read: IOPS=3317, BW=13.0MiB/s (13.6MB/s)(2332MiB/180001msec)
    clat (usec): min=209, max=535634, avg=296.20, stdev=1443.62
     lat (usec): min=210, max=535635, avg=297.13, stdev=1443.62
    clat percentiles (usec):
     |  1.00th=[  233],  5.00th=[  241], 10.00th=[  243], 20.00th=[  247],
     | 30.00th=[  251], 40.00th=[  253], 50.00th=[  258], 60.00th=[  265],
     | 70.00th=[  269], 80.00th=[  281], 90.00th=[  302], 95.00th=[  330],
     | 99.00th=[  627], 99.50th=[ 1074], 99.90th=[ 4817], 99.95th=[ 9896],
     | 99.99th=[34866]
   bw (  KiB/s): min=   32, max=15432, per=100.00%, avg=13284.66, stdev=2559.17, samples=359
   iops        : min=    8, max= 3858, avg=3321.16, stdev=639.79, samples=359
  lat (usec)   : 250=28.88%, 500=69.77%, 750=0.58%, 1000=0.21%
  lat (msec)   : 2=0.36%, 4=0.08%, 10=0.06%, 20=0.03%, 50=0.02%
  lat (msec)   : 100=0.01%, 250=0.01%, 500=0.01%, 750=0.01%
  cpu          : usr=3.56%, sys=7.57%, ctx=597121, majf=0, minf=14
  IO depths    : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     issued rwts: total=597112,0,0,0 short=0,0,0,0 dropped=0,0,0,0
     latency   : target=0, window=0, percentile=100.00%, depth=1

Run status group 0 (all jobs):
   READ: bw=13.0MiB/s (13.6MB/s), 13.0MiB/s-13.0MiB/s (13.6MB/s-13.6MB/s), io=2332MiB (2446MB), run=180001-180001msec
  • 随机写

-rw=randwrite ,我们启用了50个进程模拟
我们可以看到IOPS是1108 ，BW带宽只有 4434KiB/s
write: IOPS=1108, BW=4434KiB/s (4540kB/s)(781MiB/180331msec); 0 zone resets

# fio -filename=/tmp/write.dat -direct=1 -iodepth 1  -rw=randwrite -ioengine=psync -bs=4k -size=4G -numjobs=50 -runtime=180 -group_reporting -name=sqe_100write_4k
sqe_100write_4k: (g=0): rw=randwrite, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=psync, iodepth=1
...
fio-3.29
Starting 50 processes
sqe_100write_4k: Laying out IO file (1 file / 4096MiB)
Jobs: 50 (f=50): [w(50)][100.0%][w=3692KiB/s][w=923 IOPS][eta 00m:00s] 
sqe_100write_4k: (groupid=0, jobs=50): err= 0: pid=7128: Fri Mar  4 17:54:18 2022
  write: IOPS=1108, BW=4434KiB/s (4540kB/s)(781MiB/180331msec); 0 zone resets
    clat (usec): min=311, max=5969.7k, avg=45097.62, stdev=236640.38
     lat (usec): min=313, max=5969.7k, avg=45098.90, stdev=236640.39
    clat percentiles (usec):
     |  1.00th=[    750],  5.00th=[   1057], 10.00th=[   1303],
     | 20.00th=[   1647], 30.00th=[   1844], 40.00th=[   2343],
     | 50.00th=[   3064], 60.00th=[   3687], 70.00th=[   4047],
     | 80.00th=[   4948], 90.00th=[  22938], 95.00th=[ 164627],
     | 99.00th=[1283458], 99.50th=[1753220], 99.90th=[2634023],
     | 99.95th=[3640656], 99.99th=[5939135]
   bw (  KiB/s): min=  350, max=103337, per=100.00%, avg=7568.53, stdev=265.17, samples=10555
   iops        : min=   50, max=25811, avg=1887.29, stdev=66.26, samples=10555
  lat (usec)   : 500=0.09%, 750=0.95%, 1000=3.17%
  lat (msec)   : 2=29.75%, 4=34.89%, 10=18.41%, 20=2.36%, 50=2.42%
  lat (msec)   : 100=1.74%, 250=2.29%, 500=1.44%, 750=0.83%, 1000=0.34%
  lat (msec)   : 2000=1.02%, >=2000=0.30%
  cpu          : usr=0.03%, sys=0.15%, ctx=220103, majf=0, minf=821
  IO depths    : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     issued rwts: total=0,199884,0,0 short=0,0,0,0 dropped=0,0,0,0
     latency   : target=0, window=0, percentile=100.00%, depth=1

Run status group 0 (all jobs):
  WRITE: bw=4434KiB/s (4540kB/s), 4434KiB/s-4434KiB/s (4540kB/s-4540kB/s), io=781MiB (819MB), run=180331-180331msec

Disk stats (read/write):
  sda: ios=0/218756, merge=0/1942, ticks=0/9721312, in_queue=9809977, util=100.00%
  • 随机读写混合

70%随机读-rwmixread=70 ，30%随机写
从结果中我们可以看到70%随机读的IOPS 是1802 ，30%随机写是774 ，而带宽分别是7209KiB/s，3096KiB/s。
read: IOPS=1802, BW=7209KiB/s (7382kB/s)(1268MiB/180113msec)
write: IOPS=774, BW=3096KiB/s (3171kB/s)(545MiB/180113msec); 0 zone resets

# fio -filename=/tmp/read_write.dat -direct=1 -iodepth=1 -rw=randrw -rwmixread=70 -ioengine=psync -bs=4k -size=4G -numjobs=50 -runtime=180 -group_reporting -name=randrw_70read_4k

randrw_70read_4k: (g=0): rw=randrw, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=psync, iodepth=1
...
fio-3.29
Starting 50 processes
randrw_70read_4k: Laying out IO file (1 file / 4096MiB)
Jobs: 6 (f=6): [m(1),_(7),m(1),_(7),m(1),_(4),m(1),_(6),m(1),_(14),m(1),_(6)][2.2%][r=10.9MiB/s,w=4884KiB/s][r=2801,w=1221 IOPS][eta 02h:11m:59s]
randrw_70read_4k: (groupid=0, jobs=50): err= 0: pid=8027: Fri Mar  4 18:01:37 2022
  read: IOPS=1802, BW=7209KiB/s (7382kB/s)(1268MiB/180113msec)
    clat (usec): min=225, max=3503.6k, avg=18238.79, stdev=55447.72
     lat (usec): min=226, max=3503.6k, avg=18239.86, stdev=55447.72
    clat percentiles (usec):
     |  1.00th=[    330],  5.00th=[    553], 10.00th=[    635],
     | 20.00th=[    799], 30.00th=[   1074], 40.00th=[   1631],
     | 50.00th=[   3326], 60.00th=[   8717], 70.00th=[  17433],
     | 80.00th=[  28967], 90.00th=[  47973], 95.00th=[  69731],
     | 99.00th=[ 147850], 99.50th=[ 196084], 99.90th=[ 429917],
     | 99.95th=[ 859833], 99.99th=[2936013]
   bw (  KiB/s): min=  350, max=25119, per=100.00%, avg=8438.00, stdev=106.40, samples=15326
   iops        : min=   50, max= 6272, avg=2094.52, stdev=26.64, samples=15326
  write: IOPS=774, BW=3096KiB/s (3171kB/s)(545MiB/180113msec); 0 zone resets
    clat (usec): min=251, max=3576.5k, avg=22074.38, stdev=134044.57
     lat (usec): min=252, max=3576.5k, avg=22075.53, stdev=134044.60
    clat percentiles (usec):
     |  1.00th=[    347],  5.00th=[    537], 10.00th=[    603],
     | 20.00th=[    709], 30.00th=[    816], 40.00th=[    955],
     | 50.00th=[   1188], 60.00th=[   1565], 70.00th=[   2311],
     | 80.00th=[   4080], 90.00th=[   9634], 95.00th=[  35390],
     | 99.00th=[ 583009], 99.50th=[1082131], 99.90th=[1501561],
     | 99.95th=[1837106], 99.99th=[3472884]
   bw (  KiB/s): min=  350, max=13399, per=100.00%, avg=3753.05, stdev=51.84, samples=14762
   iops        : min=   50, max= 3343, avg=923.38, stdev=13.00, samples=14762
  lat (usec)   : 250=0.06%, 500=2.99%, 750=16.22%, 1000=12.87%
  lat (msec)   : 2=18.13%, 4=10.02%, 10=10.01%, 20=8.68%, 50=13.12%
  lat (msec)   : 100=5.06%, 250=1.98%, 500=0.44%, 750=0.11%, 1000=0.09%
  lat (msec)   : 2000=0.18%, >=2000=0.02%
  cpu          : usr=0.06%, sys=0.14%, ctx=488255, majf=0, minf=1027
  IO depths    : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     issued rwts: total=324593,139424,0,0 short=0,0,0,0 dropped=0,0,0,0
     latency   : target=0, window=0, percentile=100.00%, depth=1

Run status group 0 (all jobs):
   READ: bw=7209KiB/s (7382kB/s), 7209KiB/s-7209KiB/s (7382kB/s-7382kB/s), io=1268MiB (1330MB), run=180113-180113msec
  WRITE: bw=3096KiB/s (3171kB/s), 3096KiB/s-3096KiB/s (3171kB/s-3171kB/s), io=545MiB (571MB), run=180113-180113msec

Disk stats (read/write):
  sda: ios=324721/139458, merge=0/2, ticks=5905787/3076202, in_queue=8984158, util=100.00%

fio结果分析

 read : io=717120KB, bw=23915KB/s, iops=5978, runt= 29986msec

   #这一行表示读

   #io表示执行了多少M的io，bw表示平均io带宽,iops表示每秒的输入输出量，runt表示线程运行时间

   clat (usec): min=162, max=17094, avg=1178.92, stdev=701.84

      lat (usec): min=162, max=17094, avg=1179.36, stdev=702.21

     clat percentiles (usec):

      |  1.00th=[  338],  5.00th=[  462], 10.00th=[  556], 20.00th=[  692],

      | 30.00th=[  804], 40.00th=[  908], 50.00th=[ 1012], 60.00th=[ 1144],

      | 70.00th=[ 1304], 80.00th=[ 1528], 90.00th=[ 1960], 95.00th=[ 2384],

      | 99.00th=[ 3824], 99.50th=[ 4576], 99.90th=[ 6560], 99.95th=[ 7584],

      | 99.99th=[ 9920]

    #io延迟包括三种：slat,clat,lat,关系是lat=slat+clat;

    #slat表示fio submit某个I/O的延迟，称slat为提交延迟;

    #clat表示fio complete某个I/O的延迟，称clat为提交延迟;

    #lat表示从fio将请求提交给内核，再到内核完成这个I/O为止所需的相应时间,称lat为响应时间;

    #usec:微妙，msec:毫秒

    cpu          : usr=0.17%, sys=27.06%, ctx=263958, majf=0, minf=10

     #usr表示用户空间进程;

     #sys表示内核空间进程;

测试过程中可以通过iostat进行监控

# iostat -d /dev/vdd -x -k 1 10
Linux 3.10.0-1160.el7.x86_64 (HLWHOST)  2024年04月24日  _x86_64_        (2 CPU)

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd               0.00     0.00    0.15    0.00     3.47     1.98    72.27     0.00    1.90    0.26   63.18   0.06   0.00

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd               0.00     0.00    0.00    0.00     0.00     0.00     0.00     0.00    0.00    0.00    0.00   0.00   0.00

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd               0.00     0.00    0.00    0.00     0.00     0.00     0.00     0.00    0.00    0.00    0.00   0.00   0.00

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd               0.00     0.00    0.00  768.00     0.00 393216.00  1024.00     3.01    3.92    0.00    3.92   0.09   6.90

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd               0.00    10.00    0.00 3425.00     0.00 1703940.50   995.00    10.82    3.16    0.00    3.16   0.08  28.80

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd              75.00     0.00 50577.00    0.00 810672.00     0.00    32.06     6.66    0.13    0.13    0.00   0.01  75.70

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd             191.00     0.00 61584.00    0.00 988688.00     0.00    32.11     8.92    0.14    0.14    0.00   0.02 100.00

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd             221.00     0.00 61714.00    0.00 991904.00     0.00    32.15     8.91    0.14    0.14    0.00   0.02 100.00

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd             104.00     0.00 67142.00    0.00 1076528.00     0.00    32.07     8.69    0.13    0.13    0.00   0.01  99.70

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vdd             150.00     0.00 66050.00    0.00 1059904.00     0.00    32.09     8.82    0.13    0.13    0.00   0.02  99.90

rrqms：每秒这个设备相关的读取请求有多少被Merge了（当系统调用需要读取数据的时候，VFS将请求发到各个FS，如果FS发现不同的读取请求读取的是相同Block的数据，FS会将这个请求合并Merge）
wrqm/s：每秒这个设备相关的写入请求有多少被Merge了。
rsec/s：The number of sectors read from the device per second.
wsec/s：The number of sectors written to the device per second.
rKB/s：The number of kilobytes read from the device per second.
wKB/s：The number of kilobytes written to the device per second.
avgrq-sz：平均请求扇区的大小,The average size (in sectors) of the requests that were issued to the device.
avgqu-sz：是平均请求队列的长度。毫无疑问，队列长度越短越好,The average queue length of the requests that were issued to the device.
await：每一个IO请求的处理的平均时间（单位是微秒毫秒）。这里可以理解为IO的响应时间，一般地系统IO响应时间应该低于5ms，如果大于10ms就比较大了。这个时间包括了队列时间和服务时间，也就是说，一般情况下，await大于svctm，它们的差值越小，则说明队列时间越短，反之差值越大，队列时间越长，说明系统出了问题。
svctm：表示平均每次设备I/O操作的服务时间（以毫秒为单位）。如果svctm的值与await很接近，表示几乎没有I/O等待，磁盘性能很好。如果await的值远高于svctm的值，则表示I/O队列等待太长，系统上运行的应用程序将变慢。
%util：在统计时间内所有处理IO时间，除以总共统计时间。例如，如果统计间隔1秒，该设备有0.8秒在处理IO，而0.2秒闲置，那么该设备的%util = 0.8/1 = 80%，所以该参数暗示了设备的繁忙程度，一般地，如果该参数是100%表示磁盘设备已经接近满负荷运行了（当然如果是多磁盘，即使%util是100%，因为磁盘的并发能力，所以磁盘使用未必就到了瓶颈）。

参考和转载

https://mp.weixin.qq.com/s/8sFFg92guraijP9C6oJ9GQ
https://blog.csdn.net/cyh183269855/article/details/73916667
https://blog.csdn.net/chongbin007/article/details/120918462
https://mp.weixin.qq.com/s/n4izPla6GhOe81AONLnreQ

标签：rw,th,0.00,await,IO,fio,0.0%
From： https://www.cnblogs.com/OpenSourceSite/p/18155892

相关文章

  • 用 React 结合 SAP UI5 Web Components 来开发 SAP Fiori 应用
    用React结合SAPUI5WebComponents来开发SAPFiori应用阿里云开发者​已认证账号​关注 6人赞同了该文章简介：用React结合SAPUI5WebComponents来开发SAPFiori应用在FioriFundamentals和SAPUI5WebComponent诞生之前，SA......
  • 盘点那些好用的SAP FIORI App(二) -上传凭证Upload Journal Entry
    前面我有提到过，SAP录入凭证的界面是用户不友好的，并且介绍了几种快速录入的方法，科目分配模型，参考凭证等，但是今天我要讲到的这个app是最实用的，强烈推荐大家使用，因为这个可以用excel的方法直接上传过账，并且不需要额外的定制开发。AppID:F2548点击app进入如下界面，我们可以先......
  • SAP Fiori开发中的JavaScript基础知识1 - 背景介绍
    1.背景开发SAPFiori应用程序过程中，不可避免的要用到JavaScript去增强或影响UI的行为。对于传统ABAPer，JavaScript的语言特性和风格与ABAP是有较大的不同的。接下来的一段时间，我会尝试整理在SAPFiori开发过程中会常用到的一些JavaScript基础知识，并结合介绍在SAPBAS中开发Fio......
  • SAP Fiori开发中的JavaScript基础知识2 - 变量，操作符，值，类型
    1.JavaScript代码示例在介绍JavaScript具体语法前，让我们先看一段在Web应用程序过程中的JS代码片。<!DOCTYPEhtml><html> <head> <metacharset="utf-8"/> <title>FirstJavaScriptApplication!</title> <scriptsrc="js/myExternal.js&q......
  • 使用 Docker 部署 Fiora 在线聊天室平台
    一、Fiora介绍Fiora简介Fiora是一款开源免费的在线聊天系统。GitHub：https://github.com/yinxin630/fioraFiora功能注册账号并登录，可以长久保存你的数据加入现有群组或者创建自己的群组，来和大家交流和任意人私聊，并添加其为好友多种消息类型，包括文本/表情/图片/......
  • Go语言核心36讲 42 | bufio包中的数据类型 （上）
    今天，我们来讲另一个与I/O操作强相关的代码包bufio。bufio是“bufferedI/O”的缩写。顾名思义，这个代码包中的程序实体实现的I/O操作都内置了缓冲区。bufio包中的数据类型主要有：Reader；Scanner；Writer和ReadWriter。与io包中的数据类型类似，这些类型的值也都需要在初始化的时......
  • Go语言核心36讲 43 | bufio包中的数据类型（下）
    你好，我是郝林，我今天继续分享bufio包中的数据类型。在上一篇文章中，我提到了bufio包中的数据类型主要有Reader、Scanner、Writer和ReadWriter。并着重讲到了bufio.Reader类型与bufio.Writer类型，今天，我们继续专注bufio.Reader的内容来进行学习。知识扩展问题：bufio.Reader类型读......
  • 磁盘性能检测（time&&fio）
    一、time命令：timeddif=/tmp/test1of=/tmp/test2bs=8kcount=51200oflag=dsync参数说明：1、time有计时作用，dd用于复制，从if读出，写到of；2、if=/dev/zero不产生IO，因此可以用来测试纯写速度；3、同理of=/dev/null不产生IO，可以用来测试纯读速度；4、将/tmp/test1拷贝到/tmp/te......
  • ABAP Draft handling 在 SAP 现代 Fiori 应用中的重要作用
    在SAPABAP开发中，"Drafthandling"（草稿处理）是指一种处理业务对象的机制，使用户能够在事务过程中保存未提交的更改，以便随时回到之前的状态或者在适当的时候提交更改。这个机制的实现允许用户在长时间的事务中保存中间状态，而不必担心数据的不一致性或者丢失。"Drafthandling"的核心......
  • 什么是 @openui5/themelib_sap_fiori_3
    @openui5/themelib_sap_fiori_3是SAPUI5的一个主题库，它包含SAPFiori3的样式和设计元素。SAPFiori是SAP的用户体验（UserExperience，简称UX）设计语言，其设计准则注重简单性，可个性化，并且能在不同设备之间提供一致的用户体验。Fiori3是Fiori的最新版本，提供了更加现代化和......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99