精华内容
下载资源
问答
  • 并行传输数据和串行传输数据SATA hard drive connections are faster than older PATA hard drive connections and the same can be said for external cabling standards, but this is counter-intuitive: why ...
    并行传输数据和串行传输数据

    并行传输数据和串行传输数据

    SATA hard drive connections are faster than older PATA hard drive connections and the same can be said for external cabling standards, but this is counter-intuitive: why wouldn’t the parallel transmission be faster?

    SATA硬盘驱动器的连接速度比旧的PATA硬盘驱动器连接要快,对于外部电缆连接标准也可以这么说,但这是违反直觉的:为什么并行传输不会更快?

    Today’s Question & Answer session comes to us courtesy of SuperUser—a subdivision of Stack Exchange, a community-driven grouping of Q&A web sites.

    今天的“问答”环节由SuperUser提供,它是Stack Exchange的一个分支,该社区是由社区驱动的Q&A网站分组。

    问题 (The Question)

    SuperUser reader Modest is curious about the data transfer rates of parallel and serial connections:

    SuperUser阅读器Modest对并行和串行连接的数据传输速率感到好奇:

    Intuitively, you would think that parallel data transmission should be faster than serial data transmission; in parallel you are transferring many bits at the same time, whereas in serial you are doing one bit at a time.

    凭直觉,您会认为并行数据传输应该比串行数据传输快; 并行操作是同时传输许多位,而串行操作是一次传输一位。

    So what makes SATA interfaces faster than PATA, PCI-e devices faster than PCI, and serial ports faster than parallel?

    那么,什么使SATA接口比PATA更快,PCI-e设备比PCI更快,串行端口比并行更快?

    While it’s easy to fall into the reasoning that SATA is newer than PATA, there must be a more concrete mechanism at work than just age.

    虽然很容易得出SATA比PATA更新的理由,但在工作中必须有一种比年龄更具体的机制。

    答案 (The Answer)

    SuperUser contributor Mpy offers some insight into the nature of the transmission types:

    超级用户贡献者Mpy对传输类型的性质提供了一些见解:

    You cannot formulate it this way.

    您不能以此方式制定。

    Serial transmission is slower than parallel transmission given the same signal frequency. With a parallel transmission you can transfer one word per cycle (e.g. 1 byte = 8 bits) but with a serial transmission only a fraction of it (e.g. 1 bit).

    相同的信号频率下,串行传输比并行传输要慢 在并行传输中,您可以每个周期传输一个字(例如1字节= 8位),而在串行传输中,仅传输其一小部分(例如1位)。

    The reason modern devices use serial transmission is the following:

    现代设备使用串行传输的原因如下:

    • You cannot increase the signal frequency for a parallel transmission without limit, because, by design, all signals from the transmitter need to arrive at the receiver at the same time. This cannot be guaranteed for high frequencies, as you cannot guarantee that the signal transit time is equal for all signal lines (think of different paths on the mainboard). The higher the frequency, the more tiny differences matter. Hence the receiver has to wait until all signal lines are settled — obviously, waiting lowers the transfer rate.

      您可以在不增加信号频率并行传输无极限,因为按照设计,从发射器需要的所有信号在接收器在同一时间到达。 这不能保证在高频下使用,因为您不能保证所有信号线的信号传输时间都相等(请考虑主板上的不同路径)。 频率越高,差异越小。 因此,接收器必须等到所有信号线都建立好之后,显然,等待会降低传输速率。

    • Another good point (from this post) is that one needs to consider crosstalk with parallel signal lines. The higher the frequency, the more pronounced crosstalk gets and with it the higher the probability of a corrupted word and the need to retransmit it. [1]

      另一个好处(来自本文)是,需要考虑与并行信号线的串扰。 频率越高,串扰越明显,随之而来的单词损坏和重传的可能性也越高。 [1]

    So, even if you transfer less data per cycle with a serial transmission, you can go to much higher frequencies which results in a higher net transfer rate.

    因此,即使您使用串行传输每个周期传输较少的数据,您也可以使用更高的频率,从而导致更高的净传输速率。

    [1] This also explains why UDMA-Cables (Parallel ATA with increased transfer speed) had twice as many wires as pins. Every second wire was grounded to reduce crosstalk.

    [1]这也解释了为什么UDMA电缆(具有更高传输速度的并行ATA)的导线数是引脚的两倍。 每隔两根导线接地,以减少串扰。

    Scott Chamberlain echoes Myp’s answer and expands upon the economics of design:

    斯科特·张伯伦(Scott Chamberlain)回应了Myp的回答,并扩展了设计经济学:

    The problem is synchronization.

    问题是同步。

    When you send in parallel you must measure all of the lines at the exact same moment, as you go faster the size of the window for that moment gets smaller and smaller, eventually it can get so small that some of the wires may still be stabilizing while others are finished before you ran out of time.

    并行发送时,必须在同一时刻测量所有线路,因为随着速度的加快,该时刻的窗口尺寸会越来越小,最终可能会变得很小,以至于某些电线可能仍在稳定而其他人则在您没时间用完之前就完成了。

    By sending in serial you no longer need to worry about all of the lines stabilizing, just one line. And it is more cost efficient to make one line stabilize 10 times faster than to add 10 lines at the same speed.

    通过串行发送,您无需担心所有线路都稳定下来,只需担心一条线路。 而且,使一条线的稳定速度比以相同速度添加10条线的速度快10倍,具有更高的成本效益。

    Some things like PCI Express do the best of both worlds, they do a parallel set of serial connections (the 16x port on your motherboard has 16 serial connections). By doing that each line does not need to be in perfect sync with the other lines, just as long as the controller at the other end can reorder the “packets” of data as they come in using the correct order.

    诸如PCI Express之类的东西在两全其美方面发挥了最大作用,它们完成了一组并行的串行连接(主板上的16x端口具有16个串行连接)。 通过这样做,只要另一端的控制器可以按照正确的顺序对数据的“数据包”进行重新排序,就不必与其他行完美同步。

    The How Stuff Works page for PCI-Express does a very good explination in depth on how PCI Express in serial can be faster than PCI or PCI-X in parallel.

    PCI-Express的“工作原理”页面对串行PCI Express如何比并行PCI或PCI-X更快提供了很好的深度解释。

    TL;DR Version: It is easier to make a single connection go 16 times faster than 8 connections go 2 times faster once you get to very high frequencies.

    TL; DR版本:一旦到达非常高的频率,使单个连接的传输速度比8个连接的传输速度快2倍就容易了。



    Have something to add to the explanation? Sound off in the the comments. Want to read more answers from other tech-savvy Stack Exchange users? Check out the full discussion thread here.

    有什么补充说明吗? 在评论中听起来不对。 是否想从其他精通Stack Exchange的用户那里获得更多答案? 在此处查看完整的讨论线程

    翻译自: https://www.howtogeek.com/171947/why-is-serial-data-transmission-faster-than-parallel-data-transmission/

    并行传输数据和串行传输数据

    展开全文
  • 前言:最近再搞个PCIe的高速串行总线的项目,关于串行和并行数据的传输到底谁更快,分别有哪些优势劣势呢等等一些问题现在做个整理,是对自己学习的一个记录,同时呢,也为刚刚想入门的或者对高速串行总线有些误解...

    前言:最近再搞个PCIe的高速串行总线的项目,关于串行和并行数据的传输到底谁更快,分别有哪些优势和劣势呢等等一些问题现在做个整理,是对自己学习的一个记录,同时呢,也为刚刚想入门的或者对高速串行总线有些误解的(暂且说误解把 词穷呀 最近在看主持人大赛2019,,,,,,,,,汗颜),我下面首先从总线的技术方面说起,当然只是浅显的说一下,深了咱也不会
    其次,PCIE的概念
    最后,进行PCIe的数据传输实验

    1 并行技术的简介

    1 并行传输就是将Nbit数据以成组的形式同时(在一个时钟周期下)在不同的线路上传输。分组一般8bit 16bit等

    那么为了数据能够正确的被接收端接收,每组(8bit或者16bit或者更大的数据位)数据必须在时钟上进行同步(源同步和系统同步),
    源同步:
    在这里插入图片描述
    发送端产生的数据和时钟保持一定的相位关系(clk和data都在发送端产生),并同时传输到接收端,接收端使用发送端的时钟作为采样时钟,对数据进行采样。在采样的过程中,只要保证接收端clk和data满足一定的建立时间/保持时间。数据一定能够正确接收。

    2 系统同步

    传统的数据传输通常采用系统同步的方式进行传输,多个期间时使用同一个时钟进行系统同步,器件之间的数据传输时序关系以系统时钟作为参考,如图,这种方式使各个器件处于同步工作模式,但是器件之间的时延难以确定,当系统时钟的频率增加之后,数据接收接口同步电路难以实现,因此不适合高速数据传输。
    在这里插入图片描述
    上述两种方式,PCB Layout时数据线总是成组并排布线,线间距小,线之间存在较大的耦合,导致串扰问题严重,除了数据线和时钟线之外,并行总线还有很多的控制线,走线数目多且一般是单端信号传输,抗干扰能力差,数据不能同时到达,因此并行传输的时钟频率很难达到1GHz。
    并行总线常用的接口找个图了解一下:在这里插入图片描述

    2 串行传输技术简介

    1 串行传输的原理

    串行传输指的是发送方和接收方直接的数据在单根通信线上逐位顺序传送,每一位数据都占据一个固定时间,示意图如下,,时钟频率相同,并行当然比串行要快的多,这个可以理解吧,在低速情况下,并行结构绝对是一种非常高效的传输方式,但是当传输速度非常高,并行传输的致命性缺点就出现了。因为时钟在高速的情况下,因为每一位在传输线路上不可能严格的一致,并行传输的一个字节中的每个位不会同时到达接受端就被放大了。而串行传输一位一位传输就不会出现这个问题。串行的优势就出现了,串行因为不存在并行的这些问题,就可以工作在非常高的频率下,用频率的提升掩盖它的劣势。
    在这里插入图片描述在串行传输中,发送端和接收设备必须达到bit同步,发送设备和接收设备必须以同步时钟(这个是频率可以很大,不存在数据不能同时到达的问题,人家就1bit嘛)发送和接收数据必须以同步时钟发送和接收数据,在接收端才能正确的接收数据。衡量串行串行传输通道的频宽的重要指标是波特率,数据的个数/单位时间,举个例子把,每秒传输240个字符(1个起始位。1个停止位,8个数据位),波特率:240Bd,比特率=240*10=2400b/s,对串行接口,必须设置正确的波特率,不然 你懂的(是不是想到了串口,那就对了)

    也列举几个串行接口协议的常用接口
    串口和USB及IEEE1394

    通过上面的讨论,简单介绍一下高速并行传输的瓶颈问题(也是抄来的 将就着看一下把)
    1 时序同步问题
    2 信号偏移
    3 抗干扰能力
    4设计复杂度和设计成本(线多呀!!!!!!!!)

    串行传输的优势:
    1 传输频率的提高是最大的优势,串行通信在发送端通过数据编码技术把时钟信号嵌入到数据信号中,在接收端使用时钟恢复技术,从数据中提取同步时钟信号来恢复数据,消除了传输线延迟导致的时序问题对速率的约束,实现单通道的数据传输速率10Gb/s以上。
    2 使用差分信号,抑制共模噪声产生的影响,在相同驱动电压的驱动下,差分信号的摆幅是单端信号的两倍,那么发送端就能以更低的电压发送信号,不但降低了功耗并且还抑制了电磁干扰的影响,减少对外的电磁辐射,此外,此外,此外呀,差分信号模式一般采用恒定的电流驱动,这将保证驱动器电路在任何时刻保持不变,消除了信号同步翻转而产生的同步开关噪声问题哦。
    3 线少了 你懂的的
    4 使用点对点连接方式,避免并行总线的共享机制造成的总线利用率低的问题,通信链路利用率达到100%(听起来是不是很牛b),而且在点对点拓扑情况下,阻抗的匹配端接也非常简单,一般高速串行收发器都自带匹配,实现双端端接,进一步降低反射。

    娘妈的 抄的手疼 贴个图

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    多重相位技术

    这个多啰嗦几句 我也是刚学,如有错误,请指出

    多重相位技术是实现高速串行I/O的通信技术之一,多重相位在时钟的不同相位对串行的数据流进行采样,将串行数据流转化为并行数据输出,从而实现 低速时钟处理高速时钟的的数据,如下示意图,由锁相环的多相时钟产生器输出4个相时钟信号,即在0°,90°,180°,270°上采样数据,最后由零相位时钟信号同步并行输出。采用多重相位提取电路。若输入的串行数据流比特率位x,则并行输出的数据流比特率为x / 4。
    在这里插入图片描述在这里插入图片描述

    线路编码技术

    在这里插入图片描述
    https://wenku.baidu.com/view/c3280ec0b9f3f90f76c61b38.html参看一下

    扰码传输技术

    发送预加重技术

    接收均衡技术

    这几个技术以后用到再补充吧。。。。。。。。。。。。。。。。

    展开全文
  • 串行和并行的区别,超详细!

    千次阅读 2021-02-05 22:28:27
    Stream中有两个函数parallel()sequential(),分别代表了并行和串行串行比较好理解,就是在主线程上按顺序执行逻辑代码,那么并行呢?那么我们要来说说什么是并行和并发,以前我们的CPU是单核的,多个任务是通过...

    串行执行

    **First😗*我们来说说Stream的并行和串行。Stream中有两个函数parallel()和sequential(),分别代表了并行和串行,串行比较好理解,就是在主线程上按顺序执行逻辑代码,那么并行呢?那么我们要来说说什么是并行和并发,以前我们的CPU是单核的,多个任务是通过划分时间片轮训来执行任务,这样的逻辑叫做并发。现代的CPU的多核的,有多少个核心就可以同一时间可以运行更多的任务,所以并行和并发大家就明白了。
    second:多个线程访问同一个类的synchronized方法时, 都是串行执行的 ! 就算有多个cpu也不例外 !
    synchronized方法使用了类java的内置锁, 即锁住的是方法所属对象本身. 同一个锁某个时刻只能被一个执行线程所获取,
    因此其他线程都得等待锁的释放. 因此就算你有多余的cpu可以执行, 但是你没有锁, 所以你还是不能进入synchronized方法执行, CPU因此而空闲.
    如果某个线程长期持有一个竞争激烈的锁, 那么将导致其他线程都因等待所的释放而被挂起,
    从而导致CPU无法得到利用, 系统吞吐量低下. 因此要尽量避免某个线程对锁的长期占有 !

    package Demo3;
    
    public class SyncMethod {
        public synchronized void syncMethod2() {
            try {
                System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)");
        }
    
        public synchronized void syncMethod1() {
            System.out.println("######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)");
        }
      
    
    }
    
    ```java
    package Demo3;
    
    public class Thread1  extends Thread {
    
        SyncMethod syncMethod;
    
        public Thread1(SyncMethod syncMethod) {
            this.syncMethod = syncMethod;
        }
    
        @Override
        public void run() {
            syncMethod.syncMethod2();
        }
    }
    
    
    
    
    
    package Demo3;
    
    public class Thread2 extends Thread {
        SyncMethod syncMethod;
    
        public Thread2(SyncMethod syncMethod) {
            this.syncMethod = syncMethod;
        }
    
        @Override
        public void run() {
            System.out.println("Thread2 running ...");
            syncMethod.syncMethod1();
        }
    }
    
    
    package Demo3;
    
    public class Test2 {
        public static void main(String[] args) throws InterruptedException {
            SyncMethod syncMethod = new SyncMethod();
            Thread1 thread1 = new Thread1(syncMethod);
            Thread2 thread2 = new Thread2(syncMethod);      
            thread1.start();    //先执行, 以便抢占锁
            Thread1.sleep(500); //放弃cpu, 让thread1执行, 以便获的锁
            thread2.start(); //在syncMethod1()方法获得锁时, 看看syncMethod2()方法能否执行
    
    
    //        new Thread(()->{syncMethod.syncMethod2();}).start();
    //        new Thread(()->{syncMethod.syncMethod1();}).start();
    
        }
    }
    @@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)
    Thread2 running ...
    @@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)
    ######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)
    

    多个线程访问同一个类的synchronized方法时, 都是串行执行的,很显然有长达5秒钟的时间空缺,另一个线程竟然没有加入,因此其他线程都得等待锁的释放.。因此就算你有多余的cpu可以执行, 但是你没有锁, 所以你还是不能进入synchronized方法执行, CPU因此而空闲。
    因此是串行执行。
    **

    并行执行

    **

    package Demo3;
    
    public class SyncMethod2 {
        private Object lock1 = new Object();
        private Object lock2 = new Object();
    
        public void syncMethod2() {
            synchronized (lock1) {
                try {
                    System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)");
            }
        }
    
        public void syncMethod1() {
            synchronized (lock2) {
                System.out.println("######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)");
            }
        }
    }
    
    
    package Demo3;
    
    public class Thread21 extends Thread {
        SyncMethod2 syncMethod2;
    
        public Thread21(SyncMethod2 syncMethod2) {
            this.syncMethod2 = syncMethod2;
        }
    
        @Override
        public void run() {
            syncMethod2.syncMethod2();
        }
    }
    
    
    package Demo3;
    
    public class Thread22 extends Thread {
        SyncMethod2 syncMethod2;
    
        public Thread22(SyncMethod2 syncMethod2) {
            this.syncMethod2 = syncMethod2;
        }
    
        @Override
        public void run() {
            System.out.println("Thread22 running ...");
            this.syncMethod2.syncMethod1();
        }
    }
    
    
    package Demo3;
    
    public class Test22 {
        public static void main(String[] args) {
            SyncMethod2 syncMethod2 = new SyncMethod2();
            Thread21 thread21 = new Thread21(syncMethod2);
            Thread22 thread22 = new Thread22(syncMethod2);
            thread21.start();    //先执行, 以便抢占锁
            thread22.start(); //在syncMethod1()方法获得锁时, 看看syncMethod2()方法能否执行
        }
    }
    @@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 已经获取内置锁`SyncMethod.this`)
    Thread22 running ...
    ######################## (syncMethod1, 已经获取内置锁`SyncMethod.this`, 并即将退出)
    @@@@@@@@@@@@@@@@@@@@@@@@ (syncMethod2, 即将释放内置锁`SyncMethod.this`)
    
    

    显然是并行执行命令。

    1.Synchronized修饰非静态方法,实际上是对调用该方法的对象加锁,俗称“对象锁”。

    情况1:同一个对象在两个线程中分别访问该对象的两个同步方法

    结果:会产生互斥。

    解释:因为锁针对的是对象,当对象调用一个synchronized方法时,其他同步方法需要等待其执行结束并释放锁后才能执行。

    情况2:不同对象在两个线程中调用同一个同步方法

    结果:不会产生互斥。

    解释:因为是两个对象,锁针对的是对象,并不是方法,所以可以并发执行,不会互斥。形象的来说就是因为我们每个线程在调用方法的时候都是new 一个对象,那么就会出现两个空间,两把钥匙,

    2.Synchronized修饰静态方法,实际上是对该类对象加锁,俗称“类锁”。

    情况1:用类直接在两个线程中调用两个不同的同步方法

    结果:会产生互斥。

    解释:因为对静态对象加锁实际上对类(.class)加锁,类对象只有一个,可以理解为任何时候都只有一个空间,里面有N个房间,一把锁,因此房间(同步方法)之间一定是互斥的。

    注:上述情况和用单例模式声明一个对象来调用非静态方法的情况是一样的,因为永远就只有这一个对象。所以访问同步方法之间一定是互斥的。

    情况2:用一个类的静态对象在两个线程中调用静态方法或非静态方法

    结果:会产生互斥。

    解释:因为是一个对象调用,同上。

    情况3:一个对象在两个线程中分别调用一个静态同步方法和一个非静态同步方法

    结果:不会产生互斥。

    解释:因为虽然是一个对象调用,但是两个方法的锁类型不同,调用的静态方法实际上是类对象在调用,即这两个方法产生的并不是同一个对象锁,因此不会互斥,会并发执行。

    展开全文
  • 并行(Parallel)操作特性,是Oracle为更充分利用服务器硬件处理资源,提高特定大数据量操作效率,应对海量生产数据而推出的一种技术特性。通常,我们进行的SQL处理都是单进程操作,对应单个CPU操作单元。所谓的并行...

    并行(Parallel)操作特性,是Oracle为更充分利用服务器硬件处理资源,提高特定大数据量操作效率,应对海量生产数据而推出的一种技术特性。通常,我们进行的SQL处理都是单进程操作,对应单个CPU操作单元。所谓的并行操作,就是在软硬件条件允许的情况下,Oracle调用多个处理单元分别进行处理,最后汇合结果的过程。对一些SQL进行有计划的并行操作,可以显著提高系统操作速度。

     

    1、海量数据的困局

     

    互联网络时代给世界带来很多变化,其中一项就是信息的爆炸,数据呈几何级数增长。数据库随之进入海量、洋级时代,TB级数据库已经越来越频繁的出现在各类型应用场景中。开发人员和DBA就不得不面对一个困局,如果处理海量数据。

     

     

    在传统时代,我们最常借助的一个优化手段是索引。通过检索较少的数据块,获取到符合条件的数据行rowid。“索引进入执行计划,替代全表扫描”成为我们优化的重要导向。但是,索引路径不是用户最终体验。随着数据量的增大(单表上G),即使我们的执行计划很完美,检索索引+数据块定位的时间损耗可能依然不能满足客户需求。其次,一些特定系统类型(如OLAP系统),可能就是要进行全表扫描操作,对所有数据进行检索处理。这些场合下,传统的索引中心优化就无用武之地了。

     

     

    在计算机科学中,“分治”这种古老的思想一直扮演着重要地位,无论是在软件的算法还是在硬件的体系。近年来,硬件技术,特别是多核CPU、多CPU计算机的逐渐普及,使得多核计算机、服务器开始出现在企业应用领域。多核CPU和多CPU本质上就是多处理单元并行的基础。将一个任务划分为若干个子任务,交由不同的处理单元进行同时处理,之后将结果集合汇总,是通用的单任务多处理进程模型。应该说,并行技术是建立在软硬件技术基础之上的,其中硬件技术是一个决定要素。

     

    2、Oracle的并行处理

     

    Oracle并行处理(Parallel Processing)特性主要是针对SQL语句处理的并行。目前Oracle提供支持并行的操作包括如下类型:

     

    ü        并行查询操作;

    ü        并行DDL。对数据对象的DDL操作;

    ü        并行DML。进行并行的数据更新修改;

     

    在具体的应用场景上,有如下场景:

     

    ü        数据表、索引范围扫描的查询;

    ü        批量增加、修改和删除操作;

    ü        数据表、索引对象的创建;

    ü        DBMS_STATS”收集统计量;

    ü        备份恢复管理器Recovery Manager的使用;

     

    Oracle中,一共包括三种进程Process类型,分别为客户进程Client Process、服务进程Server Process和后台进程Background Process。其中,进行数据块读取、修改写入等实际操作的都是服务进程Server Process。Server Process是客户进程在数据库实例上的代理进程,保持着一对一的关系。由此,一般的SQL语句都是单进程串行操作的。

     

    Oracle并行操作涉及的过程同一般并行操作的模型基本相似,包括处理单元和协调单元两类进程组成。首先,处理的单一任务划分为若干子任务。在协调进程(Coordinator)的作用下,并行操作被划分为若干子任务,分别传递给多个并行服务进程进行处理。之后,各个进程将处理结果进行汇总,交付给协调进程进行组合,作为统一的结果返回。

     

    并处处理在Oracle中是一个配置过程,包括很多参数配置和概念要素。其中最重要的两个概念就是并行度和并行伺候进程池。下面分别来介绍两个概念和相关的配置项目。

     

    3、并行度和并行伺候进程池

     

    并行度DOP(Degree Of Parallel)定义了进行并行操作时并行流的个数。DOP可以理解成进行并行处理时候,划分的并行处理单元个数。但是,在实际的情况看,进行并行处理的进程个数往往是DOP的两倍,也就是一个并行流实际上是两个处理进程在进行处理工作。这样的配置通常是为了实现进程之间的协调合作,缓解各个处理环节上的速度不匹配现象。

     

    并行度DOP是Oracle并行操作中一个重要的配置参数。目前的Oracle版本中,支持手工配置和自动配置DOP两种方式。如果是手工指定并行度,就需要在SQL语句上,通过hint来制定并行度的个数。自动配置DOP的含义是Oracle根据当前实际负载和并行进程池的状况,经过计算自动的出的适应性并行度。下面是一些Oracle中与并行度相关的参数。

     

     

    SQL> show parameter parallel

     

    NAME                                 TYPE        VALUE

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

    fast_start_parallel_rollback         string      LOW

    parallel_adaptive_multi_user         boolean     TRUE

    parallel_automatic_tuning            boolean     FALSE

    parallel_degree_limit                string      CPU

    parallel_degree_policy               string      MANUAL

    parallel_execution_message_size      integer     16384

    parallel_force_local                 boolean     FALSE

    parallel_instance_group              string     

    parallel_io_cap_enabled              boolean     FALSE

    parallel_max_servers                 integer     10

    parallel_min_percent                 integer     0

    parallel_min_servers                 integer     0

    parallel_min_time_threshold          string      AUTO

    parallel_server                      boolean     FALSE

    parallel_server_instances            integer     1

    parallel_servers_target              integer     4

    parallel_threads_per_cpu             integer     2

    recovery_parallelism                 integer     0

     

     

    上面参数的含义,会在本系列中逐渐使用和介绍。

     

    DOP是一个配置项目,实际的并行工作还需要真是存在的进程完成。从上文的背景介绍中,一个session只对应一个Server Process,进行操作处理实际都需要Server Process来完成。并行处理中,Oracle引入了并行伺候进程池的概念。并行伺候进程池是一个进程的集合,针对需要进行并行处理的SQL操作,会从处理池中分配出适当数量的服务进程来进行处理。

     

    一些与并行服务进程相关的参数,如下:

     

    SQL> show parameter parallel_m

     

    NAME                                 TYPE        VALUE

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

    parallel_max_servers                 integer     10

    parallel_min_percent                 integer     0

    parallel_min_servers                 integer     0

     

     

     

    4、一个并行Query的示例

     

    下面针对一个大数据量表,演示一下并行SQL的执行计划。首先还是环境准备:

     

     

    SQL> select * from v$version where rownum<2;

     

    BANNER

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

    Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - Production

     

    SQL> select count(*) from t;

     

      COUNT(*)

    ----------

         1110542

     

     

    使用并行操作,最常用的方式是通过Hint进行指定(当然也可以通过对象Parallel属性指定)。下面是没有使用并行和使用并行两个执行计划的差异演示。

     

     

    SQL> set linesize 10000;

    SQL> set pagesize 10000;

    SQL> explain plan for select * from t;

    已解释。

     

    已用时间:  00: 00: 00.03

    SQL> select * from table(dbms_xplan.display(format => 'advanced'));

     

    PLAN_TABLE_OUTPUT

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

    Plan hash value: 1601196873

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

    | Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |

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

    |   0 | SELECT STATEMENT  |      |  1156K|   106M|  4464   (1)| 00:00:54 |

    |   1 |  TABLE ACCESS FULL| T    |  1156K|   106M|  4464   (1)| 00:00:54 |

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

    (篇幅原因,有删节…)

     

    针对一般的SQL查询,是不使用Parallel Query特性的。下面针对Hint使用:

     

     

    SQL> explain plan for select /*+ parallel */ * from t;

    已解释。

     

    已用时间:  00: 00: 00.06

    SQL> select * from table(dbms_xplan.display(format => 'advanced'));

    PLAN_TABLE_OUTPUT

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

    Plan hash value: 3050126167

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

    | Id  | Operation            | Name     | Rows  | Bytes | Cost (%CPU)| Time     |    TQ  |IN-OUT| PQ Distrib |

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

    |   0 | SELECT STATEMENT     |          |  1156K|   106M|  2478   (1)| 00:00:30 |        |      |            |

    |   1 |  PX COORDINATOR      |          |       |       |            |          |        |      |            |

    |   2 |   PX SEND QC (RANDOM)| :TQ10000 |  1156K|   106M|  2478   (1)| 00:00:30 |  Q1,00 | P->S | QC

    |   3 |    PX BLOCK ITERATOR |          |  1156K|   106M|  2478   (1)| 00:00:30 |  Q1,00 | PCWC |            |

    |   4 |     TABLE ACCESS FULL| T        |  1156K|   106M|  2478   (1)| 00:00:30 |  Q1,00 | PCWP |            |

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

    Automatic Degree of Parallelism Information:

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

     

       - Degree of Parallelism of 2 is derived from scan of object SYS.T

     

    Note

    -----

    -automatic DOP: Computed Degree of Parallelism is 2

     

     

    上面的执行计划,可以看出将全表扫描分割为多个DOP进行处理,之后汇总到协调者进程中,返回结果。

     

    同时,使用parallel的hint后,没有显示指定出并行度。Oracle采用自动并行度方式,采用2作为并行度。

     

    最后,时间使用上。估算出的执行计划只需要使用30s,而之前的串行计划则需要接近一分钟时间。

     

    5、谨慎处理并行

     

    最后,想谈谈并行的一些使用注意原则。

     

    ü        慎用并行。并行处理使用的目的是在提高系统软硬件资源使用率,从而提高SQL执行效率。但是,并不是所有SQL使用并行都可以提高性能。同索引一样,使用并行也是有成本付出的,这就是多进程之间启动和协调成本。通常,只有在处理超大规模数据、而且没有其他常规优化方法,并且证明并行可以带来提升的情况下,才考虑使用并行;

    ü        统一并行。同其他优化方案一样,并行是否使用,哪个SQL使用并行,并行度取值多少。这些问题不是单个模块和开发人员可以确定的,需要系统整体考虑。如果说索引消耗的是空间和处理资源的话,并行额外付出是处理CPU协调成本。这些优化方法最好有统一的优化方案全局考量和跟踪,决不能各行其是,引起性能新问题;

    ü        确定并行。并行处理是需要各种参数进行配合使用的,我们希望使用并行,就要保证实际执行的语句确实在进行并行处理。这要通过不断的跟踪执行计划和处理过程来实现。

     

     

    Oracle Parallel特性是一柄双刃剑,要小心仔细对待。

    展开全文
  • 并行(Parallel)操作特性,是Oracle为更充分利用服务器硬件处理资源,提高特定大数据量操作效率,应对海量生产数据而推出的一种技术特性。通常,我们进行的SQL处理都是单进程操作,对应单个CPU操作单元。所谓的并行...
  • 串行并行,并发

    2018-12-18 10:32:00
    串行 就是传统意义上的同步、顺序的意思,按照一定的执行步骤顺序执行每个环节 并行 就是传统意义上的异步、同时的意思,同时执行接收到的多个任务 并发 同时接收多个任务,同时执行多个任务,但是具体到某个时刻,...
  • CPU、核心,进程、线程,串行、并发、并行
  • 1、计算机硬件基本组成 ... 运算器:算术逻辑运算单元(ALU,Arithmetic Logic Unit),负责执行所有的数学逻辑工作 控制器:控制单元(CU,Control Unit),控制计算机的所有其他部件,如输入输出设备以及存储器
  •  * 指定taskId跳转到的activityId,自动使用最后的assignee.  */  public RollbackTaskCmd(String taskId, String activityId) {  this.taskId = taskId;  this.activityId = activityId;  this....
  • 运算器:算术逻辑运算单元(ALU,Arithmetic Logic Unit),负责执行所有的数学逻辑工作 控制器:控制单元(CU,Control Unit),控制计算机的所有其他部件,如输入输出设备以及存储器 寄存器
  • 并发请求,串行执行

    2020-06-20 23:44:40
    站点收到并发请求需要串行处理,或者并行执行的业务某个环节需要串行处理。 二、分析 1,只能针对操作同一条数据的业务处理串行处理,整体必须并行处理。 2,因为执行速度很快,发生并发时,最好每一条都被执行,...
  • 在第六讲中,本文以冒泡排序 Bubble Sort、归并排序 Merge Sort 排序网络中的双调排序 Bitonic Sort 为例, 讲解如何从数据结构课上学的串行并行排序方法转换到并行排序,并附GPU实现代码。 在并行方法中,我们将...
  • 它有并行和串行两种数据输出形式。并行ADC虽然数据传输速度快,但有引脚多、体积大、占用微处理器接口多的缺点;而串行ADC的传输速率目前已经可以做得很高,并且具有体积小、功耗低、占用微处理器接口少的优点。因此...
  • 为了打破行业壁垒,更快地将区块链投入实际业务场景,打造基于去中心化理念的业务实践,百度云百度区块链实验室基于百度自研XuperChain技术内核,突破共识机制、单机计算和串行处理三大技术瓶颈,并融合ABC与IoT等...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,542
精华内容 2,616
关键字:

并行环节和串行环节