使用 PGStrom 2 (GPU JOIN, BulkScan, GpuPreAgg, ...)

最新推荐文章于 2024-03-14 11:31:29 发布
最新推荐文章于 2024-03-14 11:31:29 发布
阅读量643 收藏
点赞数
分类专栏： 转载 数据库性能优化 文章标签： postgresql 数据库 性能优化

Postgres2015全国用户大会将于11月20至21日在北京丽亭华苑酒店召开。本次大会嘉宾阵容强大，国内顶级PostgreSQL数据库专家将悉数到场，并特邀欧洲、俄罗斯、日本、美国等国家和地区的数据库方面专家助阵:

  • Postgres-XC项目的发起人铃木市一(SUZUKI Koichi)
  • Postgres-XL的项目发起人Mason Sharp
  • pgpool的作者石井达夫(Tatsuo Ishii)
  • PG-Strom的作者海外浩平(Kaigai Kohei)
  • Greenplum研发总监姚延栋
  • 周正中(德哥), PostgreSQL中国用户会创始人之一
  • 汪洋，平安科技数据库技术部经理
  • ……
 
  • 2015年度PG大象会报名地址：http://postgres2015.eventdove.com/
  • PostgreSQL中国社区： http://postgres.cn/
  • PostgreSQL专业1群： 3336901（已满）
  • PostgreSQL专业2群： 100910388
  • PostgreSQL专业3群： 150657323


BUG fixed, 测试了一下。
JOIN性能确实好很多，主要体现在。
1. BuldkScan
300毫秒左右，而seqscan需要1500毫秒。
2. GpuJoin
约4.5秒。而hash join约8秒。 
   
   

    
    

     
     postgres=# explain (analyze,verbose,costs,buffers,timing) select count(*) from t1 natural join t2 natural join t3;
    
    

    
    

     
                                                                               QUERY PLAN                                                                           
    
    

    
    

     
     ---------------------------------------------------------------------------------------------------------------------------------------------------------------
    
    

    
    

     
      Aggregate  (cost=592268.52..592268.53 rows=1 width=0) (actual time=12571.551..12571.551 rows=1 loops=1)
    
    

    
    

     
        Output: pgstrom.count((pgstrom.nrows()))
    
    

    
    

     
        Buffers: shared hit=132771
    
    

    
    

     
        ->  Custom Scan (GpuPreAgg)  (cost=425951.98..570768.69 rows=17 width=4) (actual time=12548.700..12571.530 rows=28 loops=1)
    
    

    
    

     
              Output: pgstrom.nrows()
    
    

    
    

     
              Bulkload: On (density: 100.00%)
    
    

    
    

     
              Reduction: NoGroup
    
    

    
    

     
              Features: format: tuple-slot, bulkload: unsupported
    
    

    
    

     
              Buffers: shared hit=132771
    
    

    
    

     
              ->  Custom Scan (GpuJoin)  (cost=422951.98..567268.52 rows=10000000 width=0) (actual time=12337.214..12531.078 rows=10000000 loops=1)
    
    

    
    

     
                    Pseudo Scan: (t1.c1)::integer, (t1.c2)::integer, (t3.c1)::integer, (t3.c2)::integer
    
    

    
    

     
                    Bulkload: On (density: 100.00%)
    
    

    
    

     
                    Depth 1: GpuHashJoin, HashKeys: (t1.c1, t1.c2), JoinQual: ((t1.c1 = t3.c1) AND (t1.c2 = t3.c2))
    
    

    
    

     
                             Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 495.91MB planned 739.10MB, nbatches: 1 planned 1)
    
    

    
    

     
                    Features: format: heap-tuple, bulkload: supported
    
    

    
    

     
                    Buffers: shared hit=132771
    
    

    
    

     
                    ->  Custom Scan (GpuJoin)  (cost=211479.50..355978.48 rows=10000000 width=16) (actual time=6805.095..7022.021 rows=10000000 loops=1)
    
    

    
    

     
                          Output: t1.c1, t1.c2, t2.c1, t2.c2
    
    

    
    

     
                          Pseudo Scan: t1.c1::integer, t1.c2::integer, t2.c1::integer, t2.c2::integer
    
    

    
    

     
                          Bulkload: On (density: 100.00%)
    
    

    
    

     
                          Depth 1: GpuHashJoin, HashKeys: (t1.c1, t1.c2), JoinQual: ((t1.c1 = t2.c1) AND (t1.c2 = t2.c2))
    
    

    
    

     
                                   Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 495.91MB planned 739.10MB, nbatches: 1 planned 1)
    
    

    
    

     
                          Features: format: tuple-slot, bulkload: supported
    
    

    
    

     
                          Buffers: shared hit=88523
    
    

    
    

     
                          ->  Custom Scan (BulkScan) on public.t1  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=12.278..335.416 rows=10000000 loops=1)
    
    

    
    

     
                                Output: t1.c1, t1.c2
    
    

    
    

     
                                Features: format: tuple-slot, bulkload: supported
    
    

    
    

     
                                Buffers: shared hit=44275
    
    

    
    

     
                          ->  Seq Scan on public.t2  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=0.009..1510.590 rows=10000000 loops=1)
    
    

    
    

     
                                Output: t2.c1, t2.c2
    
    

    
    

     
                                Buffers: shared hit=44248
    
    

    
    

     
                    ->  Seq Scan on public.t3  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=0.017..1539.207 rows=10000000 loops=1)
    
    

    
    

     
                          Output: t3.c1, t3.c2
    
    

    
    

     
                          Buffers: shared hit=44248
    
    

    
    

     
      Planning time: 0.856 ms
    
    

    
    

     
      Execution time: 14226.754 ms
    
    

    
    

     
     (36 rows)
    
    

   
   

   
   

    
    

   
   

   
   

    
    

     
     postgres=# set pg_strom.enabled=off;
    
    

    
    

     
     SET
    
    

    
    

     
     postgres=# explain (analyze,verbose,costs,buffers,timing) select count(*) from t1 natural join t2 natural join t3;
    
    

    
    

     
                                                                        QUERY PLAN                                                                    
    
    

    
    

     
     -------------------------------------------------------------------------------------------------------------------------------------------------
    
    

    
    

     
      Aggregate  (cost=1889780.00..1889780.01 rows=1 width=0) (actual time=23863.974..23863.974 rows=1 loops=1)
    
    

    
    

     
        Output: count(*)
    
    

    
    

     
        Buffers: shared hit=132744, temp read=184849 written=184073
    
    

    
    

     
        ->  Hash Join  (cost=666622.00..1864780.00 rows=10000000 width=0) (actual time=6751.553..23007.967 rows=10000000 loops=1)
    
    

    
    

     
              Hash Cond: ((t1.c1 = t3.c1) AND (t1.c2 = t3.c2))
    
    

    
    

     
              Buffers: shared hit=132744, temp read=184849 written=184073
    
    

    
    

     
              ->  Hash Join  (cost=333311.00..994748.00 rows=10000000 width=16) (actual time=3369.316..12137.123 rows=10000000 loops=1)
    
    

    
    

     
                    Output: t1.c1, t1.c2, t2.c1, t2.c2
    
    

    
    

     
                    Hash Cond: ((t1.c1 = t2.c1) AND (t1.c2 = t2.c2))
    
    

    
    

     
                    Buffers: shared hit=88496, temp read=86300 written=85912
    
    

    
    

     
                    ->  Seq Scan on public.t1  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=0.008..1079.109 rows=10000000 loops=1)
    
    

    
    

     
                          Output: t1.c1, t1.c2
    
    

    
    

     
                          Buffers: shared hit=44248
    
    

    
    

     
                    ->  Hash  (cost=144248.00..144248.00 rows=10000000 width=8) (actual time=3368.576..3368.576 rows=10000000 loops=1)
    
    

    
    

     
                          Output: t2.c1, t2.c2
    
    

    
    

     
                          Buckets: 131072 (originally 131072)  Batches: 256 (originally 128)  Memory Usage: 4073kB
    
    

    
    

     
                          Buffers: shared hit=44248, temp written=33847
    
    

    
    

     
                          ->  Seq Scan on public.t2  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=0.007..1096.536 rows=10000000 loops=1)
    
    

    
    

     
                                Output: t2.c1, t2.c2
    
    

    
    

     
                                Buffers: shared hit=44248
    
    

    
    

     
              ->  Hash  (cost=144248.00..144248.00 rows=10000000 width=8) (actual time=3382.059..3382.059 rows=10000000 loops=1)
    
    

    
    

     
                    Output: t3.c1, t3.c2
    
    

    
    

     
                    Buckets: 131072 (originally 131072)  Batches: 256 (originally 128)  Memory Usage: 4073kB
    
    

    
    

     
                    Buffers: shared hit=44248, temp written=33847
    
    

    
    

     
                    ->  Seq Scan on public.t3  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=0.010..1102.204 rows=10000000 loops=1)
    
    

    
    

     
                          Output: t3.c1, t3.c2
    
    

    
    

     
                          Buffers: shared hit=44248
    
    

    
    

     
      Planning time: 0.594 ms
    
    

    
    

     
      Execution time: 23864.050 ms
    
    

    
    

     
     (29 rows)

8个表的JOIN，不使用 GPU。 

  
  

   
   postgres=# explain (analyze,verbose,costs,buffers,timing) select count(*) from t1 natural join t2 natural join t3 natural join t4 natural join t5 natural join t6 natural join t7 natural join t8 ;
  
  

  
  

   
                                                                                   QUERY PLAN                                                                                
  
  

  
  

   
   --------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  

  
  

   
    Aggregate  (cost=5773641.04..5773641.05 rows=1 width=0) (actual time=78621.151..78621.151 rows=1 loops=1)
  
  

  
  

   
      Output: count(*)
  
  

  
  

   
      Buffers: shared hit=435962, temp read=518383 written=516199
  
  

  
  

   
      ->  Hash Join  (cost=2720512.24..5748641.21 rows=9999931 width=0) (actual time=33751.548..77761.816 rows=10000000 loops=1)
  
  

  
  

   
            Hash Cond: ((t1.c1 = t4.c1) AND (t1.c2 = t4.c2))
  
  

  
  

   
            Buffers: shared hit=435962, temp read=518383 written=516199
  
  

  
  

   
            ->  Hash Join  (cost=1526935.54..3930456.05 rows=9999954 width=48) (actual time=18264.080..53774.071 rows=10000000 loops=1)
  
  

  
  

   
                  Output: t1.c1, t1.c2, t2.c1, t2.c2, t3.c1, t3.c2, t5.c1, t5.c2, t7.c1, t7.c2, t8.c1, t8.c2
  
  

  
  

   
                  Hash Cond: ((t1.c1 = t5.c1) AND (t1.c2 = t5.c2))
  
  

  
  

   
                  Buffers: shared hit=347463, temp read=304863 written=303577
  
  

  
  

   
                  ->  Hash Join  (cost=333358.83..2151331.98 rows=9999977 width=32) (actual time=3509.315..30357.234 rows=10000000 loops=1)
  
  

  
  

   
                        Output: t1.c1, t1.c2, t2.c1, t2.c2, t3.c1, t3.c2, t8.c1, t8.c2
  
  

  
  

   
                        Hash Cond: ((t1.c1 = t8.c1) AND (t1.c2 = t8.c2))
  
  

  
  

   
                        Buffers: shared hit=258967, temp read=110794 written=110406
  
  

  
  

   
                        ->  Merge Join  (cost=48.41..1261770.78 rows=10000000 width=24) (actual time=0.077..17169.673 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t1.c1, t1.c2, t2.c1, t2.c2, t3.c1, t3.c2
  
  

  
  

   
                              Merge Cond: (t1.c1 = t3.c1)
  
  

  
  

   
                              Join Filter: (t1.c2 = t3.c2)
  
  

  
  

   
                              Buffers: shared hit=214719
  
  

  
  

   
                              ->  Merge Join  (cost=23.83..782865.84 rows=10000000 width=16) (actual time=0.059..9851.866 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t1.c1, t1.c2, t2.c1, t2.c2
  
  

  
  

   
                                    Merge Cond: (t1.c1 = t2.c1)
  
  

  
  

   
                                    Join Filter: (t1.c2 = t2.c2)
  
  

  
  

   
                                    Buffers: shared hit=143146
  
  

  
  

   
                                    ->  Index Scan using idx1 on public.t1  (cost=0.43..303939.43 rows=10000000 width=8) (actual time=0.034..2221.148 rows=10000000 loops=1)
  
  

  
  

   
                                          Output: t1.c1, t1.c2
  
  

  
  

   
                                          Buffers: shared hit=71573
  
  

  
  

   
                                    ->  Index Scan using idx2 on public.t2  (cost=0.43..303939.43 rows=10000000 width=8) (actual time=0.013..2620.760 rows=10000000 loops=1)
  
  

  
  

   
                                          Output: t2.c1, t2.c2
  
  

  
  

   
                                          Buffers: shared hit=71573
  
  

  
  

   
                              ->  Index Scan using idx3 on public.t3  (cost=0.43..303939.43 rows=10000000 width=8) (actual time=0.013..2675.423 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t3.c1, t3.c2
  
  

  
  

   
                                    Buffers: shared hit=71573
  
  

  
  

   
                        ->  Hash  (cost=144247.77..144247.77 rows=9999977 width=8) (actual time=3508.083..3508.083 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t8.c1, t8.c2
  
  

  
  

   
                              Buckets: 131072 (originally 131072)  Batches: 256 (originally 128)  Memory Usage: 4073kB
  
  

  
  

   
                              Buffers: shared hit=44248, temp written=33847
  
  

  
  

   
                              ->  Seq Scan on public.t8  (cost=0.00..144247.77 rows=9999977 width=8) (actual time=0.034..1189.104 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t8.c1, t8.c2
  
  

  
  

   
                                    Buffers: shared hit=44248
  
  

  
  

   
                  ->  Hash  (cost=994748.05..994748.05 rows=9999977 width=16) (actual time=14751.206..14751.206 rows=10000000 loops=1)
  
  

  
  

   
                        Output: t5.c1, t5.c2, t7.c1, t7.c2
  
  

  
  

   
                        Buckets: 131072  Batches: 256  Memory Usage: 2855kB
  
  

  
  

   
                        Buffers: shared hit=88496, temp read=86300 written=129560
  
  

  
  

   
                        ->  Hash Join  (cost=333312.20..994748.05 rows=9999977 width=16) (actual time=3485.575..12066.617 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t5.c1, t5.c2, t7.c1, t7.c2
  
  

  
  

   
                              Hash Cond: ((t7.c1 = t5.c1) AND (t7.c2 = t5.c2))
  
  

  
  

   
                              Buffers: shared hit=88496, temp read=86300 written=85912
  
  

  
  

   
                              ->  Seq Scan on public.t7  (cost=0.00..144247.77 rows=9999977 width=8) (actual time=0.017..1176.896 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t7.c1, t7.c2
  
  

  
  

   
                                    Buffers: shared hit=44248
  
  

  
  

   
                              ->  Hash  (cost=144248.48..144248.48 rows=10000048 width=8) (actual time=3484.279..3484.279 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t5.c1, t5.c2
  
  

  
  

   
                                    Buckets: 131072 (originally 131072)  Batches: 256 (originally 128)  Memory Usage: 4073kB
  
  

  
  

   
                                    Buffers: shared hit=44248, temp written=33847
  
  

  
  

   
                                    ->  Seq Scan on public.t5  (cost=0.00..144248.48 rows=10000048 width=8) (actual time=0.012..1191.389 rows=10000000 loops=1)
  
  

  
  

   
                                          Output: t5.c1, t5.c2
  
  

  
  

   
                                          Buffers: shared hit=44248
  
  

  
  

   
            ->  Hash  (cost=994748.05..994748.05 rows=9999977 width=16) (actual time=15486.754..15486.754 rows=10000000 loops=1)
  
  

  
  

   
                  Output: t4.c1, t4.c2, t6.c1, t6.c2
  
  

  
  

   
                  Buckets: 131072  Batches: 256  Memory Usage: 2855kB
  
  

  
  

   
                  Buffers: shared hit=88496, temp read=86300 written=129560
  
  

  
  

   
                  ->  Hash Join  (cost=333312.20..994748.05 rows=9999977 width=16) (actual time=3494.887..12813.050 rows=10000000 loops=1)
  
  

  
  

   
                        Output: t4.c1, t4.c2, t6.c1, t6.c2
  
  

  
  

   
                        Hash Cond: ((t6.c1 = t4.c1) AND (t6.c2 = t4.c2))
  
  

  
  

   
                        Buffers: shared hit=88496, temp read=86300 written=85912
  
  

  
  

   
                        ->  Seq Scan on public.t6  (cost=0.00..144247.77 rows=9999977 width=8) (actual time=0.025..1214.920 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t6.c1, t6.c2
  
  

  
  

   
                              Buffers: shared hit=44248
  
  

  
  

   
                        ->  Hash  (cost=144248.48..144248.48 rows=10000048 width=8) (actual time=3493.640..3493.640 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t4.c1, t4.c2
  
  

  
  

   
                              Buckets: 131072 (originally 131072)  Batches: 256 (originally 128)  Memory Usage: 4073kB
  
  

  
  

   
                              Buffers: shared hit=44248, temp written=33847
  
  

  
  

   
                              ->  Seq Scan on public.t4  (cost=0.00..144248.48 rows=10000048 width=8) (actual time=0.016..1191.688 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t4.c1, t4.c2
  
  

  
  

   
                                    Buffers: shared hit=44248
  
  

  
  

   
    Planning time: 46.170 ms
  
  

  
  

   
    Execution time: 78621.977 ms
  
  

  
  

   
   (78 rows)
使用GPU。 

  
  

   
   postgres=# set pg_strom.enabled=on;
  
  

  
  

   
   SET
  
  

  
  

   
   postgres=# explain (analyze,verbose,costs,buffers,timing) select count(*) from t1 natural join t2 natural join t3 natural join t4 natural join t5 natural join t6 natural join t7 natural join t8 ;
  
  

  
  

   
                                                                                              QUERY PLAN                                                                                            
  
  

  
  

   
   -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  

  
  

   
    Aggregate  (cost=1663562.75..1663562.76 rows=1 width=0) (actual time=48858.541..48858.541 rows=1 loops=1)
  
  

  
  

   
      Output: pgstrom.count((pgstrom.nrows()))
  
  

  
  

   
      Buffers: shared hit=354038
  
  

  
  

   
      ->  Custom Scan (GpuPreAgg)  (cost=1453270.24..1642063.09 rows=17 width=4) (actual time=48794.894..48858.504 rows=28 loops=1)
  
  

  
  

   
            Output: pgstrom.nrows()
  
  

  
  

   
            Bulkload: On (density: 100.00%)
  
  

  
  

   
            Reduction: NoGroup
  
  

  
  

   
            Features: format: tuple-slot, bulkload: unsupported
  
  

  
  

   
            Buffers: shared hit=354038
  
  

  
  

   
            ->  Custom Scan (GpuJoin)  (cost=1450270.24..1638562.92 rows=9999931 width=0) (actual time=48438.139..48777.446 rows=10000000 loops=1)
  
  

  
  

   
                  Pseudo Scan: (t1.c1)::integer, (t1.c2)::integer, (t4.c1)::integer, (t4.c2)::integer
  
  

  
  

   
                  Bulkload: On (density: 100.00%)
  
  

  
  

   
                  Depth 1: GpuHashJoin, HashKeys: (t1.c1, t1.c2), JoinQual: ((t1.c1 = t4.c1) AND (t1.c2 = t4.c2))
  
  

  
  

   
                           Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 801.09MB planned 560.27MB, nbatches: 1 planned 2)
  
  

  
  

   
                  Features: format: heap-tuple, bulkload: supported
  
  

  
  

   
                  Buffers: shared hit=354038
  
  

  
  

   
                  ->  Custom Scan (GpuJoin)  (cost=422951.98..567268.52 rows=10000000 width=24) (actual time=9964.714..10167.462 rows=10000000 loops=1)
  
  

  
  

   
                        Output: t1.c1, t1.c2, t2.c1, t2.c2, t3.c1, t3.c2
  
  

  
  

   
                        Pseudo Scan: t1.c1::integer, t1.c2::integer, t2.c1::integer, t2.c2::integer, t3.c1::integer, t3.c2::integer
  
  

  
  

   
                        Bulkload: On (density: 100.00%)
  
  

  
  

   
                        Depth 1: GpuHashJoin, HashKeys: (t1.c1, t1.c2), JoinQual: ((t1.c1 = t3.c1) AND (t1.c2 = t3.c2))
  
  

  
  

   
                                 Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 495.91MB planned 739.10MB, nbatches: 1 planned 1)
  
  

  
  

   
                        Features: format: tuple-slot, bulkload: supported
  
  

  
  

   
                        Buffers: shared hit=132771
  
  

  
  

   
                        ->  Custom Scan (GpuJoin)  (cost=211479.50..355978.48 rows=10000000 width=16) (actual time=5018.376..5238.156 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t1.c1, t1.c2, t2.c1, t2.c2
  
  

  
  

   
                              Pseudo Scan: t1.c1::integer, t1.c2::integer, t2.c1::integer, t2.c2::integer
  
  

  
  

   
                              Bulkload: On (density: 100.00%)
  
  

  
  

   
                              Depth 1: GpuHashJoin, HashKeys: (t1.c1, t1.c2), JoinQual: ((t1.c1 = t2.c1) AND (t1.c2 = t2.c2))
  
  

  
  

   
                                       Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 495.91MB planned 739.10MB, nbatches: 1 planned 1)
  
  

  
  

   
                              Features: format: tuple-slot, bulkload: supported
  
  

  
  

   
                              Buffers: shared hit=88523
  
  

  
  

   
                              ->  Custom Scan (BulkScan) on public.t1  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=12.040..322.669 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t1.c1, t1.c2
  
  

  
  

   
                                    Features: format: tuple-slot, bulkload: supported
  
  

  
  

   
                                    Buffers: shared hit=44275
  
  

  
  

   
                              ->  Seq Scan on public.t2  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=0.008..1528.913 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t2.c1, t2.c2
  
  

  
  

   
                                    Buffers: shared hit=44248
  
  

  
  

   
                        ->  Seq Scan on public.t3  (cost=0.00..144248.00 rows=10000000 width=8) (actual time=0.022..1529.554 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t3.c1, t3.c2
  
  

  
  

   
                              Buffers: shared hit=44248
  
  

  
  

   
                  ->  Custom Scan (GpuJoin)  (cost=845250.50..990105.67 rows=9999835 width=40) (actual time=25935.700..27197.613 rows=10000000 loops=1)
  
  

  
  

   
                        Output: t4.c1, t4.c2, t5.c1, t5.c2, t6.c1, t6.c2, t7.c1, t7.c2, t8.c1, t8.c2
  
  

  
  

   
                        Pseudo Scan: t4.c1::integer, t4.c2::integer, t5.c1::integer, t5.c2::integer, t6.c1::integer, t6.c2::integer, t7.c1::integer, t7.c2::integer, t8.c1::integer, t8.c2::integer
  
  

  
  

   
                        Bulkload: On (density: 100.00%)
  
  

  
  

   
                        Depth 1: GpuHashJoin, HashKeys: (t4.c1, t4.c2), JoinQual: ((t4.c1 = t5.c1) AND (t4.c2 = t5.c2))
  
  

  
  

   
                                 Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 495.91MB planned 739.10MB, nbatches: 1 planned 1)
  
  

  
  

   
                        Features: format: tuple-slot, bulkload: supported
  
  

  
  

   
                        Buffers: shared hit=221267
  
  

  
  

   
                        ->  Custom Scan (GpuJoin)  (cost=634200.09..778635.44 rows=9999835 width=32) (actual time=20268.808..20269.446 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t4.c1, t4.c2, t6.c1, t6.c2, t7.c1, t7.c2, t8.c1, t8.c2
  
  

  
  

   
                              Pseudo Scan: t4.c1::integer, t4.c2::integer, t6.c1::integer, t6.c2::integer, t7.c1::integer, t7.c2::integer, t8.c1::integer, t8.c2::integer
  
  

  
  

   
                              Bulkload: On (density: 100.00%)
  
  

  
  

   
                              Depth 1: GpuHashJoin, HashKeys: (t4.c1, t4.c2), JoinQual: ((t4.c1 = t8.c1) AND (t4.c2 = t8.c2))
  
  

  
  

   
                                       Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 495.91MB planned 739.10MB, nbatches: 1 planned 1)
  
  

  
  

   
                              Features: format: tuple-slot, bulkload: supported
  
  

  
  

   
                              Buffers: shared hit=177019
  
  

  
  

   
                              ->  Custom Scan (GpuJoin)  (cost=422951.23..567266.84 rows=9999906 width=24) (actual time=14136.992..14560.294 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t4.c1, t4.c2, t6.c1, t6.c2, t7.c1, t7.c2
  
  

  
  

   
                                    Pseudo Scan: t4.c1::integer, t4.c2::integer, t6.c1::integer, t6.c2::integer, t7.c1::integer, t7.c2::integer
  
  

  
  

   
                                    Bulkload: On (density: 100.00%)
  
  

  
  

   
                                    Depth 1: GpuHashJoin, HashKeys: (t4.c1, t4.c2), JoinQual: ((t4.c1 = t7.c1) AND (t4.c2 = t7.c2))
  
  

  
  

   
                                             Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 495.91MB planned 739.10MB, nbatches: 1 planned 1)
  
  

  
  

   
                                    Features: format: tuple-slot, bulkload: supported
  
  

  
  

   
                                    Buffers: shared hit=132771
  
  

  
  

   
                                    ->  Custom Scan (GpuJoin)  (cost=211479.13..355977.88 rows=9999977 width=16) (actual time=7517.167..7812.485 rows=10000000 loops=1)
  
  

  
  

   
                                          Output: t4.c1, t4.c2, t6.c1, t6.c2
  
  

  
  

   
                                          Pseudo Scan: t4.c1::integer, t4.c2::integer, t6.c1::integer, t6.c2::integer
  
  

  
  

   
                                          Bulkload: On (density: 100.00%)
  
  

  
  

   
                                          Depth 1: GpuHashJoin, HashKeys: (t4.c1, t4.c2), JoinQual: ((t4.c1 = t6.c1) AND (t4.c2 = t6.c2))
  
  

  
  

   
                                                   Nrows (in:10000000 out:10000000, 100.00% planned 100.00%), KDS-Hash (size: 495.91MB planned 739.10MB, nbatches: 1 planned 1)
  
  

  
  

   
                                          Features: format: tuple-slot, bulkload: supported
  
  

  
  

   
                                          Buffers: shared hit=88523
  
  

  
  

   
                                          ->  Custom Scan (BulkScan) on public.t4  (cost=0.00..144248.48 rows=10000048 width=8) (actual time=12.063..322.445 rows=10000000 loops=1)
  
  

  
  

   
                                                Output: t4.c1, t4.c2
  
  

  
  

   
                                                Features: format: tuple-slot, bulkload: supported
  
  

  
  

   
                                                Buffers: shared hit=44275
  
  

  
  

   
                                          ->  Seq Scan on public.t6  (cost=0.00..144247.77 rows=9999977 width=8) (actual time=0.009..1559.817 rows=10000000 loops=1)
  
  

  
  

   
                                                Output: t6.c1, t6.c2
  
  

  
  

   
                                                Buffers: shared hit=44248
  
  

  
  

   
                                    ->  Seq Scan on public.t7  (cost=0.00..144247.77 rows=9999977 width=8) (actual time=0.022..1527.810 rows=10000000 loops=1)
  
  

  
  

   
                                          Output: t7.c1, t7.c2
  
  

  
  

   
                                          Buffers: shared hit=44248
  
  

  
  

   
                              ->  Seq Scan on public.t8  (cost=0.00..144247.77 rows=9999977 width=8) (actual time=0.023..1521.776 rows=10000000 loops=1)
  
  

  
  

   
                                    Output: t8.c1, t8.c2
  
  

  
  

   
                                    Buffers: shared hit=44248
  
  

  
  

   
                        ->  Seq Scan on public.t5  (cost=0.00..144248.48 rows=10000048 width=8) (actual time=0.015..1499.270 rows=10000000 loops=1)
  
  

  
  

   
                              Output: t5.c1, t5.c2
  
  

  
  

   
                              Buffers: shared hit=44248
  
  

  
  

   
    Planning time: 82.220 ms
  
  

  
  

   
    Execution time: 52799.548 ms
  
  

  
  

   
   (92 rows)

[参考]
1.  http://blog.163.com/digoal@126/blog/static/16387704020157147333619/
Postgresql中国用户会
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GPU数据库PG_strom的安装及使用
03-23
GPU数据库PG_strom的安装及使用，包括postgresql的安装， PG_strom的安装。
探秘高效数据库处理：PG-Strom
最新发布
gitblog_00077的博客
03-26 381
探秘高效数据库处理：PG-Strom 项目地址:https://gitcode.com/heterodb/pg-strom 项目简介 PG-Strom 是一个开源项目，它为 PostgreSQL 数据库提供了硬件加速功能。该项目的主要目标是提升大数据处理的速度，通过将部分计算任务卸载到 GPU（图形处理器），从而实现对海量数据的快速并行处理。 技术解析 PG-Strom 采用了 CUDA（Comp...
pgstrom_init_gpujoin(void)
fgh123的博客
05-07 400
/* * * Entrypoint of GpuJoin */ void pgstrom_init_gpujoin(void) { /* turn on/off gpunestloop */ DefineCustomBoolVariable("pg_strom.enable_gpunestloop", "Enables the use of GpuNes...
PG-Strom学习总结
Han_L的博客
03-26 2769
PG-Strom学习总结 PG-Strom是一个PostgreSQL的扩展模块，是连接PostgreSQL和GPU的桥梁，利用GPU来加速SQL上的操作。其GPU代码生成器会根据SQL语句生成对应的在英伟达的CUDA（统一计算架构）的GPU程序。目前主要支持SCAN、JOIN和GROUP BY操作。PG-Strom的“SSD-to-GPU Direct SQL”机制允许直接将数据从NVME的固态硬...
PostgreSQL异构引擎pg-strom源码解读
weixin_40730091的博客
10-24 1369
源码中的测试样例SQL
使用多GPU训练模型.md
04-06
使用多GPU训练模型.md
gpu.js：GPU加速JavaScript
02-02
用GPU.js编写的矩阵乘法（在大小为512 x 512的2个矩阵上执行矩阵乘法）： 浏览器 < script src =" dist/gpu-browser.min.js " > </ script > < script > // GPU is a constructor and namespace...
免费使用阿里天池GPU深度学习.pdf
01-18
1.使用对象：想使用高端GPU且免费的初学者 2.参数：每天免费使用训练7.5小时 3.内容：对如何使用操作进行详细说明 因为深深的喜欢深度学习计算机视觉，苦于自己没有大型机器，网上可以使用阿里但没有教程，特写此...
threejs性能优化与GPU优化.md
10-19
threejs性能优化与GPU优化
GPU-Z.0.3.6.rar_GPU-Z.0.3_gpu-z
09-23
japierdole co za chujostwo zajebane kurwa mac sza&#322 chuja
pg-strom, PG Strom开发知识库.zip
10-11
pg-strom, PG Strom开发知识库 pgpg strom是PostgreSQL数据库的定制扫描提供程序模块。 它是用于使用GPU设备进行accelarate顺序扫描，hash-基于表的Join 和聚合函数。 它的基本概念是CPU和GPU应该集中在它们具有优势的工作负载上，
07_Nexus的介绍和安装
11-20
nexus的介绍和安装，nexus是为了用于服务本地开发机的私有maven中央库。
pg_strom:PostgreSQL 的 FDW 模块使用 GPU 进行异步超并行查询执行
06-29
发展 PG-Strom开发 存储库移至
PG-Strom源码分析
喜欢打篮球的普通人
01-18 1084
文章目录1.环境2.PG-Strom启动3.如何自定义一个Custom Scan？ 1.环境 硬件： CentOS7，3.10.0-1160.49.1.el7.x86_64 Tesla T4 GPU 软件： PG14.1, PG-Strom4.0 CUDA 11.5 2.PG-Strom启动 何时开始执行_PG_init？ 下面是PG代码的执行流程 (gdb) bt #0 _PG_init () at src/main.c:560 #1 0x0000000000b0d00f in interna
PG-STROM 2.3 安装与部署
huu163的博客
04-17 1521
一、Tesla 基础环境部署 1、安装GPU Tesla Driver 在编译Linux kernel module所需要的安装包，包括gcc、kernel devel、kernel headers # uname -r 3.10.0-514.26.2.el7.x86_64 # yum install -y gcc kernel-devel-($uname -r) kernel-heade...
pg_strom: PostgreSQL GPU加速器
gitblog_00021的博客
03-14 252
pg_strom: 提升 PostgreSQL 性能的 GPU 加速库 项目简介 pg_strom 是一个用于扩展 PostgreSQL 数据库性能的开源项目。该项目通过将部分计算任务迁移到 GPU（图形处理器）上，利用其并行处理能力实现对大量数据集的高效处理。 能用来做什么？ pg_strom 可以帮助数据库管理员和开发者在 PostgreSQL 中提升查询性能，特别适合处理大数据量、高并发的场...
PG-Strom V2.3 Release
huu163的博客
04-06 178
-- GPU服务器已出厂，亟需新的GPU服务器23333（难受！） -- 等到我的GPU环境处理好了再出最新的更新内容 主要的变动： 1、GpuJoin 支持对inner buffer的并行创建 -- 老版本的GpuJoin的inner buffer只是由后台的进程（backend process）进行创建，因此对于分区表的并行查询会相对较慢。因此本版本允许后台进程或者并行查询的para...
pg_strom: 提升 PostgreSQL 性能的 GPU 加速库
gitblog_00014的博客
03-14 330
pg_strom: 提升 PostgreSQL 性能的 GPU 加速库 项目简介 pg_strom 是一个用于扩展 PostgreSQL 数据库性能的开源项目。该项目通过将部分计算任务迁移到 GPU（图形处理器）上，利用其并行处理能力实现对大量数据集的高效处理。 能用来做什么？ pg_strom 可以帮助数据库管理员和开发者在 PostgreSQL 中提升查询性能，特别适合处理大数据量、高并发的场...
使用tensorflow-gpu 2.x测试NLP bert
06-08
好的，要使用TensorFlow-GPU 2.x测试NLP BERT，您需要先安装CUDA和cuDNN，然后安装TensorFlow-GPU 2.x和BERT。以下是一些步骤： 1. 安装CUDA和cuDNN 您需要下载并安装适合您系统的CUDA和cuDNN版本。可以在NVIDIA...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值