精华内容
下载资源
问答
  • Parallel

    2013-04-10 14:38:06
    一、Parallel 1.用途  强行启用并行度来执行当前SQL。这个在Oracle 9i之后的版本可以使用,之前的版本现在没有环境进行测试。也就是说,加上这个说明,可以强行启用Oracle的多线程处理功能。举例的话,就像...

    一、Parallel
    1
    .用途

      强行启用并行度来执行当前SQL。这个在Oracle 9i之后的版本可以使用,之前的版本现在没有环境进行测试。也就是说,加上这个说明,可以强行启用Oracle的多线程处理功能。举例的话,就像电脑装了多核的CPU,但大多情况下都不会完全多核同时启用(2核以上的比较明显),使用parallel说明,就会多核同时工作,来提高效率。
      但本身启动这个功能,也是要消耗资源与性能的。所有,一般都会在返回记录数大于100万时使用,效果也会比较明显。
    2
    .语法
      /*+parallel(table_short_name,cash_number)*/
      这个可以加到insertdeleteupdateselect的后面来使用(和rule的用法差不多,有机会再分享rule的用法)

      开启parallel功能的语句是:
      alter session enable parallel dml;
      这个语句是DML语句哦,如果在程序中用,用execute的方法打开。

    3
    .实例说明
      用ERP中的transaction来说明下吧。这个table记录了所有的transaction,而且每天数据量也算相对比较大的(根据企业自身业务量而定)。假设我们现在要查看对比去年一年当中每月的进、销情况,所以,一般都会写成:

    复制内容到剪贴板 程序代码

    select to_char(transaction_date,'yyyymm') txn_month,
           sum(
            decode(
                sign(transaction_quantity),1,transaction_quantity,0
                  )
              ) in_qty,
           sum(
            decode(
                sign(transaction_quantity),-1,transaction_quantity,0
                  )
              ) out_qty
      from mtl_material_transactions mmt
    where transaction_date >= add_months(
                                to_date(    
                                    to_char(sysdate,'yyyy')||'0101','yyyymmdd'),
                                    -12)
       and transaction_date <= add_months(
                                to_date(
                                    to_char(sysdate,'yyyy')||'1231','yyyymmdd'),
                                    -12)
    group by to_char(transaction_date,'yyyymm')


      这个SQL执行起来,如果transaction_date上面有加index的话,效率还算过的去;但如果没有加index的话,估计就会半个小时内都执行不出来。这是就可以在select 后面加上parallel说明。例如:

    复制内容到剪贴板 程序代码


    select /*+parallel(mmt,10)*/
           to_char(transaction_date,'yyyymm') txn_month,
    ...


      这样的话,会大大提高执行效率。如果要将检索出来的结果insert到另一个表tmp_count_tab的话,也可以写成:

    复制内容到剪贴板 程序代码


    insert /*+parallel(t,10)*/
      into tmp_count_tab
    (
        txn_month,
        in_qty,
        out_qty
    )
    select /*+parallel(mmt,10)*/
           to_char(transaction_date,'yyyymm') txn_month,
    ...


      插入的机制和检索机制差不多,所以,在insert后面加parallel也会加速的。关于insert机制,这里暂不说了。
      Parallel后面的数字,越大,执行效率越高。不过,貌似跟server的配置还有oracle的配置有关,增大到一定值,效果就不明显了。所以,一般用8,10,12,16的比较常见。我试过用30,发现和16的效果一样。不过,数值越大,占用的资源也会相对增大的。如果是在一些packagefunction or procedure中写的话,还是不要写那么大,免得占用太多资源被DBAK
    4
    Parallel也可以用于多表
      多表的话,就是在第一后面,加入其他的就可以了。具体写法如下:
      /*+parallel(t,10) (b,10)*/
    5
    .小结

      关于执行效率,建议还是多按照index的方法来提高效果。Oracle有自带的explan road的方法,在执行之前,先看下执行计划路线,对写好的SQL tuned之后再执行。实在没办法了,再用parallel方法。Parallel比较邪恶,对开发者而言,不是好东西,会养成不好习惯,导致很多bad SQL不会暴漏,SQL Tuning的能力得不到提升。我有见过某些人create table后,从不cr

    from:http://www.docin.com/p-314345912.html

    展开全文
  • Stream和parallelStream

    万次阅读 多人点赞 2019-04-22 15:16:54
    Stream 和 parallelStream 一.什么是Stream? Stream 是在 Java8 新增的特性,普遍称其为流;它不是数据结构也不存放任何数据,其主要用于集合的逻辑处理。 二.和Iterator的区别 Iterator 做为迭代器,其按照一定的...

    Stream parallelStream

    一.什么是Stream?

    Stream 是在 Java8 新增的特性,普遍称其为流;它不是数据结构也不存放任何数据,其主要用于集合的逻辑处理。

    二.和Iterator的区别

    Iterator 做为迭代器,其按照一定的顺序迭代遍历集合中的每一个元素,并且对每个元素进行指定的操作。而 Stream 在此基础上还可以将这种操作并行化,利用多核处理器的优势快速处理集合(集合的数据会分成多个段,由多个线程处理)。

    Stream 的数据源可以有无限多个。

    三.Stream的使用

    在使用Stream之前,建义先理解接口化编程,Stream将完全依赖于接口化编程方式。接下来我们以“打印集合中的每一个元素”为例,了解一下 Stream 的使用。

    ​ 例3.1

    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); 
    numbers.stream().forEach(num->System.out.println(num));
    
    输出:1 2 3 4 5 6 7 8 9
    

    由以上的列子可以看出,Stream 的遍历方式和结果与 Iterator 没什么差别,这是因为Stream的默认遍历是和迭代器相同的,保证以往使用迭代器的地方可以方便的改写为 Stream。

    Stream 的强大之处在于其通过简单的链式编程,使得它可以方便地对遍历处理后的数据进行再处理。我们以“对集合中的数字加1,并转换成字符串”为例进行演示。

    ​ 例3.2

    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);`
    
    `List<String> strs = numbers.stream()`
    
    `.map(num->Integer.toString(++num)).collect(Collectors.toList());
    

    其中map()方法遍历处理每一个元素,并且返回一个新的Stream,随后collect方法将操作后的Stream解析为List。

    Stream还提供了非常多的操作,如filter()过滤、skip()偏移等等,想要了解更多可以去翻阅JDK1.8手册或者相关资料。

    四.并行流parallelStream

    parallelStream提供了流的并行处理,它是Stream的另一重要特性,其底层使用Fork/Join框架实现。简单理解就是多线程异步任务的一种实现。

    我们用例3.1中的示例演示一下parallelStream的使用。

    ​ 例4.1

    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); 
    numbers.parallelStream().forEach(num->System.out.println(num));
    
    输出:3 4 2 6 7 9 8 1 5
    

    我们发现,使用parallelStream后,结果并不按照集合原有顺序输出。为了进一步证明该操作是并行的,我们打印出线程信息。

    ​ 例4.2

       List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); 
       numbers.parallelStream() .forEach(num-
       		>System.out.println(Thread.currentThread().getName()+">>"+num)); 
    

    输出:

    main>>6 
    ForkJoinPool.commonPool-worker-2>>8 
    main>>5 ForkJoinPool.commonPool-worker-2>>9 
    ForkJoinPool.commonPool-worker-1>>3 
    ForkJoinPool.commonPool-worker-3>>2 
    ForkJoinPool.commonPool-worker-1>>1 
    ForkJoinPool.commonPool-worker-2>>7 
    main>>4
    

    通过例4.2可以确信parallelStream是利用多线程进行的,这可以很大程度简化我们使用并发操作。

    我们可以通过虚拟机启动参数

    -Djava.util.concurrent.ForkJoinPool.common.parallelism=N

    来设置worker的数量。

    五.并行流的陷阱

    5.1.线程安全

    由于并行流使用多线程,则一切线程安全问题都应该是需要考虑的问题,如:资源竞争、死锁、事务、可见性等等。

    5.2.线程消费

    在虚拟机启动时,我们指定了worker线程的数量,整个程序的生命周期都将使用这些工作线程;这必然存在任务生产和消费的问题,如果某个生产者生产了许多重量级的任务(耗时很长),那么其他任务毫无疑问将会没有工作线程可用;更可怕的事情是这些工作线程正在进行IO阻塞。

    本应利用并行加速处理的业务,因为工作者不够反而会额外增加处理时间,使得系统性能在某一时刻大打折扣。而且这一类问题往往是很难排查的。我们并不知道一个重量级项目中的哪一个框架、哪一个模块在使用并行流。

    接下来我们对这个问题进行演示:

    ​ 例5.1

    定义两个并行流逻辑
    执行两个并行流
    输出:
    并行流竞争输出结果

    通过示例我们会发现,第一个并行流率先获得worker线程的使用权,第二个并行流变为串行;直到第14行,第一个并行流处理完毕,第二个并行流获取worker线程,开始并行处理。

    小结:

    串行流:适合存在线程安全问题、阻塞任务、重量级任务,以及需要使用同一事务的逻辑。

    并行流:适合没有线程安全问题、较单纯的数据处理任务。

    展开全文
  • <div><p>Executing the <code>rake parallel:prepare</code> task is running one after the other (I have 12 cores and I see 12 times output from the task). <p>Is the task is supposed to do it in parallel ...
  • Parallel-Programming-with-Intel-Parallel-Studio-XE-Wrox-Programmer-to-Programmer, 资源来自于互联网
  • Parallel DG

    2020-12-25 16:57:30
    <div><p>This branch enables, finally, parallel DG integrals. Effectively all the halo data was already there, we just needed to correctly construct the extents of the exec-halo and non-exec-halo for ...
  • parallelPARALLEL:用于并行计算的Stata模块
  • Iterative Learning of Parallel Lexicons and Phrases from Non-Parallel Corpora
  • Parallel2.js to Parallel.js

    2021-01-07 16:18:19
    <div><p>Parallel2.js is now coming back to Parallel.js. <p>There is nothing more I can see which has not been moved over or superseded in code corrections and updates. <p>I will leave Parallel2.js up ...
  • Agreement-based Learning of Parallel Lexicons and Phrases from Non-Parallel Corpora
  • <div><p>This PR will add parallel DWARF parsing to Dyninst and improve existing parallel code parsing by reducing mutual exclusions and improving load balancing among threads. <p>This PR relies on the...
  • pytorch 多GPU训练总结(DataParallel的使用)

    万次阅读 多人点赞 2019-02-28 18:35:52
    这里记录用pytorch 多GPU训练 踩过的许多坑 仅针对单服务器多gpu 数据并行 而不是 多机器分布式训练 一、官方思路包装模型 这是pytorch 官方的原理图 按照这个官方的原理...上文也用dataParallel 包装了optimize...

    这里记录用pytorch 多GPU训练 踩过的许多坑   仅针对单服务器多gpu 数据并行 而不是 多机器分布式训练

    一、官方思路包装模型

    官方原理图

    这是pytorch 官方的原理图  按照这个官方的原理图  修改应该参照

    https://blog.csdn.net/qq_19598705/article/details/80396325

    上文也用dataParallel 包装了optimizer, 对照官方原理图中第二行第二个,将梯度分发出去,将每个模型上的梯度更新(第二行第三个),然后再将更新完梯度的模型参数合并到主gpu(第二行最后一个步骤)

    其实完全没必要,因为每次前向传播的时候都会分发模型,用不着反向传播时将梯度loss分发到各个GPU,单独计算梯度,再合并模型。可以就在主GPU 上根据总loss 更新模型的梯度,不用再同步其他GPU上的模型,因为前向传播的时候会分发模型。

    所以 上述链接里 不用 dataParallel 包装 optimizer。       

    DataParallel并行计算只存在在前向传播

    总结步骤:

    import os
    import torch
    args.gpu_id="2,7" ; #指定gpu id
    args.cuda = not args.no_cuda and torch.cuda.is_available() #作为是否使用cpu的判定
    #配置环境  也可以在运行时临时指定 CUDA_VISIBLE_DEVICES='2,7' Python train.py
    os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_id #这里的赋值必须是字符串,list会报错
    device_ids=range(torch.cuda.device_count())  #torch.cuda.device_count()=2
    #device_ids=[0,1] 这里的0 就是上述指定 2,是主gpu,  1就是7,模型和数据由主gpu分发
    
    if arg.cuda:
        model=model.cuda()  #这里将模型复制到gpu ,默认是cuda('0'),即转到第一个GPU 2
    if len(device_id)>1:
        model=torch.nn.DaraParallel(model);#前提是model已经.cuda() 了
    
    #前向传播时数据也要cuda(),即复制到主gpu里
    for batch_idx, (data, label) in pbar:   
        if args.cuda:
            data,label= data.cuda(),label.cuda();
        data_v = Variable(data)
        target_var = Variable(label)
        prediction= model(data_v,target_var,args)
        #这里的prediction 预测结果是由两个gpu合并过的,并行计算只存在在前向传播里
        #前向传播每个gpu计算量为 batch_size/len(device_ids),等前向传播完了将结果和到主gpu里
        #prediction length=batch_size
    
        criterion = nn.CrossEntropyLoss()
        loss = criterion(prediction,target_var) #计算loss
        optimizer.zero_grad()
        loss.backward()  
        optimizer.step()
    

    之后调用model里的函数 继承的函数可以直接调用 例如 model.state_dict() ,model.load_state_dict(torch.load(model_path)......不受影响。但是自己写的函数 要加上.module才行  model.module.forward_getfeature(x)。自己写的函数 不可以并行运算 ,只能在主gpu中运算。DataParallel并行计算仅存在在前向传播。但可以换个思路 写进forward 里或者被forward调用,多返回几个参数不就得了 return feature,predict

    二、解决多GPU 负载不均衡的问题

    我的经历是主gpu 显存爆了,而其他gpu显存只用了1/5,负载不均衡到不能忍,无法再加大batch_size

    参考:https://discuss.pytorch.org/t/dataparallel-imbalanced-memory-usage/22551/20(看了半天的英文才看懂。。。)

    负载不均衡的原因是     loss = criterion(prediction,target_var)  计算loss 占用了大量的内存,如果我们让每个gpu单独计算loss,再返回即可解决这个问题  即 prediction,loss=model(data,target)  (#如果后边不用prediction,连prediction也不用返回,只返回loss)。每个gpu返回一个loss,合到主gpu就是一个list,要loss.mean() 或loss.sum(),推荐mean.

    这样以来,所有可以在其他gpu中单独计算的都可以写进forward 里,返回结果即可。但要注意 tensor类型的数组 合并len会增加,例如prediction lenth=batchsize,但是loss这种具体的数字,合并就是list了[loss1.loss2]

    效果:主GPU 会稍微高一点。多个几百M,  但是基本实现了负载均衡

    例子:

      #model 里的forward 的函数
     def forward(self,x,target_var,args):
            feature512=self.forward_GetFeature(x)
            if target_var is None:
                return feature512;
            classifyResult = self.classifier(feature512)
            # 如果用DataParallel,forward返回feature 是返回多个GPU合并的结果
            # 每个GPU 返回 batchsize/n 个样本,n为GPU数
    
    
            #计算loss 
            center_loss = self.get_center_loss(feature512, target_var,args)
            criterion = nn.CrossEntropyLoss()
            cross_entropy_loss = criterion(classifyResult, target_var)
            #CrossEntropyLoss  已经求了softmax  分类结果直接输进去即可
    
            loss = args.center_loss_weight * center_loss + cross_entropy_loss
            prec = accuracy(classifyResult.data, target_var, topk=(1,))
            
            # 如果是返回的标量的话,那返回过去就是list,是n个GPU的结果
            # 要loss.mean() 之后 在loss.backward()
             return prec[0],loss

    三、全部代码:

    github地址:  face-recognition-supervised-by-center-loss

    这里介绍我训练的人脸识别模型,放到了github上,各位看官路过的可以点个star

    模型部分在model.py文件,即本文代码全部出自model.py。不过注释被我删掉了或者改成英文的了。

    评论区里有童鞋说我本文第一部分理解错了,可能吧,哈哈哈,不过代码应该是没错的,就是如何理解上的问题,我训练的结果是没有什么问题的。可放心食用。因为我现在不用pytorch也不做算法了,所以我就不仔细看了哈。

    展开全文
  • <div><p>The number of booleans indicating the parallel status in netCDF is large, probably larger than necessary. This leads to confusion and wrong usage. One example is in <code>source/libsrc4/nc4...
  • Parallel

    2019-06-09 12:30:38
    1,ParallelParallel类是对线程的一个很好的抽象。该类位于System.Threading.Tasks 命名空间中,提供了数据和任务的并行性。 Parallel类定义了并行的for和foreach的静态方法。对于C#的for和foreach语句而言,循环...

    1,Parallel类
    Parallel类是对线程的一个很好的抽象。该类位于System.Threading.Tasks 命名空间中,提供了数据和任务的并行性。
    Parallel类定义了并行的for和foreach的静态方法。对于C#的for和foreach语句而言,循环从一个线程中运行。Parallel类使用多个任务,因此使用多个线程来完成这个作业。
    Parallel.For()和Parallel.ForEach()方法在每次迭代中调用相同的代码,而Parallel.Invoke()方法允许同时调用不同的方法。Parallel.Invoke用于任务并行性,而Parallel.ForEach用于数据并行性。
    2,Parallel.Invoke方法
    试图让多个方法并行运行的最简单的方法就是使用Parallel类的Invoke方法,看示例代码:
    在这里插入图片描述
    执行结果:
    在这里插入图片描述

    Invoke方法接收一个Action的数组
    在这里插入图片描述
    从执行结果可以看出,没有特定的执行顺序。
    Parallel.Invoke方法只有所有方法全部完成之后才会返回,并不保证方法能同时启动执行,如果一个或者多个内核处于繁忙状态,那么底层的调度逻辑可能会延迟某些方法的执行。
    3,Parallel.For
    Parallel.For()方法类似于C#的for循环语句,也是多次执行一个任务。使用Parallel.For()方法,可以并行运行迭代。
    在For()方法中,前两个参数定义了循环的开头和结束。第三个参数是一个Action委托。整数参数是循环的迭代次数,该参数被传递给委托引用的方法。Parallel.For()方法的返回类型是ParallelLoopResult结构,它提供了循环是否结束的信息。
    在这里插入图片描述
    执行结果:
    在这里插入图片描述
    4,Parallel.ForEach
    Parallel.ForEach()方法遍历实现了IEnumerable的集合,其方法类似于foreach语句,但以异步方式遍历。这里也没有确定遍历顺序。
    在这里插入图片描述
    执行结果:
    在这里插入图片描述

    展开全文
  • parallel-studio

    2019-03-29 17:18:38
    parallel-studio破解文件;适用于windows,ubuntu等版本,
  • Parallel Algorithms.pdf

    2020-05-02 17:03:40
    Parallel Algorithms.pdf
  • 首先一般Foreach,Parallel.For,Parallel.Foreach三种情况的效率问题, 要知道的是:Parallel.Foreach性能最优,其次Parallel.For 最后 Foreach 但是这只是一般情况下,如果循环里面执行的代码块非常简单,执行时间...
  • Parallel用法

    2021-01-25 11:02:15
    Parallel用法: https://www.cnblogs.com/scmail81/archive/2018/08/22/9521096.html
  • This book was written to help you use Intel Parallel Studio XE to write programs that use the latest features of multicore CPUs. With the help of this book, you should be able to produce code that is ...
  • Parallel使用

    2018-10-01 20:59:12
    Parallel的静态For,ForEach和Invoke方法 Parallel是对Task的封装,目的是简化一些常见的编程情形中任务Task的使用,它内部使用Task。 以上三者的编程情形: Parallel.For(0,1000,i=&gt;DoWork(i));//指定某个...
  • oracle parallel

    2020-03-18 16:04:53
    最近优化一个report,首先是因为SQL关联太复杂,就新建了一个物化视图(materialized view),速度提升不少。 直到有一天,有些用户又开始抱怨速度慢了。 ...select /*+ PARALLEL (o, 4) */...
  • 两者都是复制算法,都是并行处理,但是不同的是,paralel scavenge 可以设置最大gc停顿时间(-XX:MaxGCPauseMills)以及gc时间占比(-XX:GCTimeRatio) parallel scavenge 与parnew 区别
  • listen kills parallel

    2020-11-29 14:05:58
    <div><p>I execute compilation tasks in parallel with <code>Parallel.map</code> from <a href="https://github.com/grosser/parallel/"><code>grosser/parallel</code></a>, each of which writes files to the ...
  • <div><p>It seems that my batches are executed one by one rather than been parallel? I'm using iPython. It's 32 core machine. <pre><code> import pandas, numpy, hashlib from joblib import ...
  • 本文主要介绍Parallel.Invoke的使用。 一、使用例子 class ParallelInvoke { public void Action1() { Thread.Sleep(3000); Console.WriteLine("in action1"); ...
  • 8.5.2. Parallel Scavenge和Parallel Old垃圾回收器组合 1)工作地点 Parallel Scavenge垃圾回收器工作在年轻代,而Parallel Old工作在老年代。 2)工作原理 当使用Parallel Scavenge垃圾回收器时:首先在用户线程...
  • The parallel computing memory architecture 3 Memory organization 6 Parallel programming models 14 How to design a parallel program 16 How to evaluate the performance of a parallel program 19 ...
  • c# Parallel类的使用

    2021-01-19 23:32:07
    Parallel类是对线程的抽象,提供数据与任务的并行性。类定义了静态方法For和ForEach,使用多个任务来完成多个作业。Parallel.For和Parallel.ForEach方法在每次迭代的时候调用相同的代码,而Parallel.Invoke()方法...
  • 其丰富的API及强大的表达能力极大的简化代码,提升了效率,同时还通过parallelStream提供并发操作的支持,本文探讨parallelStream方法的使用。首先看下java doc中对parallelStream的定义。A sequence of elements ...
  • --parallel" option to carbon-sync. "--parallel" will shell out to gnu parallel in order to parallelize the whisper-fill invocations. <p>This does require that parallel is installed (e.g. &...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,112
精华内容 19,244
关键字:

parallel