精华内容
下载资源
问答
  • MATLAB打开并行计算的代码为matlabpool open,或者 MATLAB如下标志,但是怎么都不行,老是提醒出现错误, 重点来了!!!! 问题在于MATLAB破解方式正确,为什么呢,楼主装软件时候序列号输是20个1,...

    楼主这几天因为项目的事情,为了缩短MATLAB的运行时间,觉得既然MATLAB有parallel这个功能,就决定用一下。

    MATLAB打开并行计算的代码为matlabpool open,或者


    MATLAB如下标志,但是怎么都不行,老是提醒出现错误,


    重点来了!!!!


    问题在于MATLAB的破解方式不正确,为什么呢,楼主装软件的时候序列号输的是20个1,装好以后将


    .dll文件拷到MATLAB的相应位置后,就算破解好了,以前也是用的相同的方法破解,基本功能都是能用的,但是并行计算却用不了



    如果你也遇到了这样的问题,解决方法在于打开安装目录下D:\Program Files (x86)\360Downloads\Software\MATLAB\bin\win64的



    文件,然后使用个人版的


    licese.lic重新破解一下就好了。

    如果各位找不到licese.lic可以找我,邮箱为2744165029@qq.com


    展开全文
  • 可达图计算目前正在解决的问题 目前抑制计算速度提升的因素如下: 计算出的可达图数据不能均匀分布在哈希表中,可参考jdk8中hashmap源码 结合BDD算法计算可达图时需要的建立带有约束的二元决策树 程序编写BDD计算...

    可达图计算目前正在解决的问题

    • 目前抑制计算速度提升的因素如下:
      1. 计算出的可达图数据不能均匀分布在哈希表中,可参考jdk8中hashmap源码
      2. 结合BDD算法计算可达图时需要的建立带有约束的二元决策树
      3. 程序编写BDD计算可达图的串行程序。
      4. 将二元决策树进行分离并优化,简化新增叶子节点过程,减少遍历原决策树的时间
      5. 将每批的触发结果进行哈希均匀分布,尽量通过布尔计算来压缩比较时间,减少线程分化
      6. CUDA代码的高效策略,并行化中的压缩与分配

    拟定的可达图计算解决方案

    方案一:

    1. 初始化GPU本地内存空间,和共享内存空间,设置哈希表的初始容量为4096,block(线程块)初始值也为4096,因此意味着哈希表每个索引值对应一个线程块。
    2. 将初始状态和变迁的布尔表达式存储在纹理内存中(纹理内存存放常量加快读取速度)
    3. 将待计算的状态分配给对应SM中,并进行相应计算
    4. SM中具体进行的操作有:
      1. 利用BDD的布尔算法得出每个SM中分配的状态在变迁发射后的状态
      2. 计算每个状态的哈希值和哈希表的索引值
      3. 将根据状态结果的索引值挂载到对应位置的本地内存中,如果对应位置无值则挂载状态为0
      4. 本地内存的单位空间采用BDD结构,挂载时与已存在数据进行异或操作,如果结果全为0则不进行数据挂载,如果结果含有1,则将第一个出现1对应的位置作为节点并把数据插入,形成ROBDD(简化有序二叉决策图)。
      5. 如果挂载点数据异或结果全为0,返回重复状态1
    5. 判断挂载数是否大于10,如果不大于10,将将BDD的结果分发给各个线程块中的共享内存中,提高SM的读取速度,减少处理时间。
    6. 当有内存中的挂载数超过了10或者哈希表所占空间超过了75%,SM则停止进行变迁触发,为避免哈希冲突,执行扩容机制,具体扩容机制如下:
      1. 将读取所有挂载状态不为0的空间,并抽取空间的某一状态计算扩容后的新索引值。
      2. 将原索引值下的所有数据复制到扩容后的新索引值下。
    7. 如果所有挂载点在计算后返回值为1,则停止计算,将本地内存数据复制到主机,并统计数据结果,统计可达状态数,完成可达图计算

    方案二:

    • 修改步骤4.4为:将计算后的状态直接挂载到索引值对应的存储位置,如果挂载数小于3则使用链式结构存储,如果大于等于3则将其用红黑树结构存储

    整体运算过程示意图

    展开全文
  • 但是,对该问题的最佳解决方案在计算上是困难,即,如果序列数量或此类序列大小任意大,则不能及时执行。 作为替代方案,已经出现了几种方法作为对该问题的启发式方法。 该项目重点是在其三个单独步骤中...
  • 异步并行的重要性和使用场景我就不再啰嗦了,一般来说我们在性能要求较高且可被异步并行执行场景将业务逻辑代码异步并行化。下面我举例一种场景,通过用户ID列表批量获取...下面一段模板代码则能解决如上问题...

            异步并行的重要性和使用场景我就不再啰嗦了,一般来说我们在性能要求较高且可被异步并行执行的场景将业务逻辑代码异步并行化。下面我举例一种场景,通过用户ID列表批量获取用户信息,当用户ID列表长度大于1时进行异步并行计算,长度小于等于1小时则不需要。下面的一段模板代码则能解决如上问题,其实代码并不高大上,但是业务系统中使用异步并行的场景较多时,则可让代码变得更加清晰、简单。

        

    package org.walkerljl.commons.asyncparallel;
    
    import org.walkerljl.commons.util.NameValue;
    
    import java.util.*;
    import java.util.concurrent.*;
    
    /**
     * 异步并行计算模板
     *
     * @param <PARAM>
     * @param <RESULT>
     * @author lijunlin
     */
    public abstract class AsyncParallelComputeTempalte<PARAM, RESULT> {
    
        /**
         * 执行计算
         *
         * @param threadPoolExecutor 执行任务的线程池
         * @param params 任务参数数组,执行引擎会为每个参数创建一个可被执行的任务。
         * @return
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public Map<PARAM, RESULT> compute(ThreadPoolExecutor threadPoolExecutor, PARAM[] params) throws ExecutionException, InterruptedException {
            return compute(threadPoolExecutor, params, false);
        }
    
        /**
         * 执行计算
         *
         * @param threadPoolExecutor 执行任务的线程池
         * @param params 任务参数数组,执行引擎会为每个参数创建一个可被执行的任务。
         * @param onlyOne 当一个计算任务被执行完成时立即返回结果,此时整个计算过程结束。
         * @return
         * @throws ExecutionException
         * @throws InterruptedException
         */
        public Map<PARAM, RESULT> compute(ThreadPoolExecutor threadPoolExecutor, PARAM[] params, boolean onlyOne) throws ExecutionException, InterruptedException {
            if (params == null || params.length == 0) {
                return null;
            }
            List<PARAM> paramList = Arrays.asList(params);
            return compute(threadPoolExecutor, paramList, onlyOne);
        }
    
        /**
         * 执行计算
         *
         * @param threadPoolExecutor 执行任务的线程池
         * @param params 任务参数列表,执行引擎会为每个参数创建一个可被执行的任务。
         * @return
         * @throws InterruptedException
         * @throws ExecutionException
         */
        public Map<PARAM, RESULT> compute(ThreadPoolExecutor threadPoolExecutor, List<PARAM> params) throws InterruptedException, ExecutionException {
            return compute(threadPoolExecutor, params, false);
        }
    
        /**
         * 执行计算
         *
         * @param threadPoolExecutor 执行任务的线程池
         * @param params 任务参数列表,执行引擎会为每个参数创建一个可被执行的任务。
         * @param onlyOne 当一个计算任务被执行完成时立即返回结果,此时整个计算过程结束。
         * @return
         * @throws InterruptedException
         * @throws ExecutionException
         */
        public Map<PARAM, RESULT> compute(ThreadPoolExecutor threadPoolExecutor, List<PARAM> params, boolean onlyOne) throws InterruptedException, ExecutionException {
            if (params == null || params.isEmpty()) {
                return null;
            }
    
            Map<PARAM, RESULT> resultMap = new HashMap<PARAM, RESULT>();
            if (params.size() == 1) {
                PARAM param = params.get(0);
                RESULT result = compute0(param);
                if (result != null) {
                    resultMap.put(param, result);
                }
            } else {
                CompletionService<NameValue<PARAM, RESULT>> completionService = new ExecutorCompletionService<NameValue<PARAM, RESULT>>(
                        threadPoolExecutor);
                List<Future<NameValue<PARAM, RESULT>>> futures = new ArrayList<Future<NameValue<PARAM, RESULT>>>();
                for (final PARAM param : params) {
                    futures.add(completionService.submit(new Callable<NameValue<PARAM, RESULT>>() {
                        @Override
                        public NameValue<PARAM, RESULT> call() throws Exception {
                            RESULT result = compute0(param);
                            if (result == null) {
                                return null;
                            }
                            return new NameValue<PARAM, RESULT>(param, result);
                        }
                    }));
                }
                for (Future<NameValue<PARAM, RESULT>> future : futures) {
                    NameValue<PARAM, RESULT> result = completionService.take().get();
                    if (result == null) {
                        continue;
                    }
                    resultMap.put(result.getName(), result.getValue());
                    if (onlyOne) {
                        break;
                    }
                }
                //cancel
                if (onlyOne) {
                    for (Future<NameValue<PARAM, RESULT>> future : futures) {
                        future.cancel(true);
                    }
                }
            }
            return resultMap;
        }
    
        /**
         * 完成单个任务计算功能
         *
         * @param param 参数
         * @return
         */
        public abstract RESULT compute0(PARAM param);
    package org.walkerljl.commons.util;
    
    
    /**
     * Simple name-value holder.
     * @author lijunlin
     * @param <N>
     * @param <V>
     */
    public class NameValue<N, V> {
    
       protected N name;
       protected V value;
    
       public NameValue() {
       }
    
       public NameValue(N name, V value) {
          this.name = name;
          this.value = value;
       }
    
       /**
        * Sets name.
        */
       public void setName(N name) {
          this.name = name;
       }
    
       /**
        * Returns name.
        */
       public N getName() {
          return name;
       }
    
       /**
        * Returns value.
        */
       public V getValue() {
          return value;
       }
    
       /**
        * Sets value.
        */
       public void setValue(V value) {
          this.value = value;
       }
    
       @Override
       public int hashCode() {
          final int prime = 31;
          int result = 1;
          result = prime * result + ((name == null) ? 0 : name.hashCode());
          result = prime * result + ((value == null) ? 0 : value.hashCode());
          return result;
       }
    
       @Override
       public boolean equals(Object obj) {
          if (this == obj)
             return true;
          if (obj == null)
             return false;
          if (getClass() != obj.getClass())
             return false;
          @SuppressWarnings("unchecked")
          NameValue<N, V> other = (NameValue<N, V>) obj;
          if (name == null) {
             if (other.name != null)
                return false;
          } else if (!name.equals(other.name))
             return false;
          if (value == null) {
             if (other.value != null)
                return false;
          } else if (!value.equals(other.value))
             return false;
          return true;
       }  
    }

      

    转载于:https://my.oschina.net/u/263253/blog/754505

    展开全文
  • 同时并行时对内存的消耗极大,超级容易爆发内存问题,而且R的内存问题一直都是R很难解决的问题,这边笔者也把看到的一些方式列出来。 当然在使用一些高大上的并行包以及框架之前,如果你能够从编码小细节优化,效率...

    要学的东西太多,无笔记不能学~~ 欢迎关注公众号,一起分享学习笔记,记录每一颗“贝壳”~

    ———————————————————————————


    终于开始攻克并行这一块了,有点小兴奋,来看看网络上R语言并行办法有哪些:

         赵鹏老师(R与并行计算)做的总结已经很到位。现在并行可以分为:


         隐式并行:隐式计算对用户隐藏了大部分细节,用户不需要知道具体数据分配方式 ,算法的实现或者底层的硬件资源分配。系统会根据当前的硬件资源来自动启动计算核心。显然,这种模式对于大多数用户来说是最喜闻乐见的。

        显性并行:显式计算则要求用户能够自己处理算例中数据划分,任务分配,计算以及最后的结果收集。因此,显式计算模式对用户的要求更高,用户不仅需要理解自己的算法,还需要对并行计算和硬件有一定的理解。值得庆幸的是,现有R中的并行计算框架,如parallel (snow,multicores),Rmpi和foreach等采用的是映射式并行模型(Mapping),使用方法简单清晰,极大地简化了编程复杂度。R用户只需要将现有程序转化为*apply或者for的循环形式之后,通过简单的API替换来实现并行计算。


    简单总结就是:

        隐式并行:OpenBLAS,Intel MKL,NVIDIA cuBLAS,H2O(参考我的博客)等

        显性并行:parallel(主打lapply应用)、foreach(主打for循环)、SupR、还有利用GPU的办法(gpuR)


          同时并行时对内存的消耗极大,超级容易爆发内存问题,而且R的内存问题一直都是R很难解决的问题,这边笔者也把看到的一些方式列出来。

          当然在使用一些高大上的并行包以及框架之前,如果你能够从编码小细节优化,效率也能提高很多,譬如:

     

    方法:速度, nrow(df)/time_taken = n 行每秒
    原始方法:1X, 856.2255行每秒(正则化为1)
    向量化方法:738X, 631578行每秒
    只考虑真值情况:1002X,857142.9行每秒
    ifelse:1752X,1500000行每秒
    which:8806X,7540364行每秒
    Rcpp:13476X,11538462行每秒
    apply处理并行



    ——————————————————————————————————————————————————————


    在最后笔者在实践中遇到的问题,进行对应的解决:

    应用一:使用parallel包时,能不能clusterExport整个函数呢?

    应用二:在使用parallel包时,报错:Error in unserialize(node$con) : error reading from connection


    ——————————————————————————————————


    一、parallel包的使用方法


    多数内容参考:R语言并行化基础与提高

    parallel是base包,所以不用install.packages就可以直接调用。

    原理:是利用CPU的核心进行训练。

    应用场景:跟apply族(lapply/sapply效果一致)( 

    R语言︱数据分组统计函数族——apply族用法与心得


    1、使用步骤

         设置核心数:no_cores <- detectCores() - 1

         步骤分群环境:cl <- makeCluster(no_cores)

         用到的变量与包复制给不同的核心:clusterEvalQ(包)、clusterExport(变量)

         运行算法:clusterApply(cl, c(9,5), get("+"), 3) 

         关闭集群:

    stopCluster(cl)


         就OK啦。但是这里面很从前不一样的是,如果有环境里面的外置变量(自己定义)那么需要额外插入,复制到不同核上面,而且如果有不同包里面的函数,都要额外加载、复制多份给不同的电脑核心。


    2、案例

    library(parallel)
    cl <- makeCluster(getOption("cl.cores", 2))
    clusterApply(cl, c(9,5), get("+"), 3)   #加减乘除
    parSapply(cl, c(9,5), get("+"), 3)   
           案例一:c1就是设置的核心数,此时是2核心,然后就可以利用clusterApply/parSapply等函数进行调用。
    xx <- 1
    clusterExport(cl, "xx")
    clusterCall(cl, function(y) xx + y, 2)
          案例二:这个里面有xx这个变量是额外定义的,所以需要额外加载,需要用clusterExport函数,导入到并行环境中。

    3、parallel内存优化与管理

    (1)注意数据容量的均匀分布

    parLapply <- function (cl = NULL, X, fun, ...) 
    {
        cl <- defaultCluster(cl)
        do.call(c, clusterApply(cl, x = splitList(X, length(cl)), 
            fun = lapply, fun, ...), quote = TRUE)
    }

        注意到splitList(X, length(cl)) ,他会将任务分割成多个部分,然后将他们发送到不同的集群中。这里一个问题就是,譬如假设有一个list,里面数据量分别是:

    (99,99,99,2,5,2)

        如果是两个核数据分为了(99,99,99)、(2,5,2),第一个核分为到了那么多任务,第二个核很少,那么就会空闲,于是乎,效率还是不高,所以数据容量要尽量均匀分布。


    (2)集群内存类型:FORK和PSOCK

    FORK适用unix/max,实现内存共享以及节省内存,大数据环境下内存问题报错少

    PSOCK适用所有(一般window都是这个)


    parallel包中通过函数来设置:

    makeCluster(4,type="FORK")

    FORK对性能提升很显著,但是window下不可适用。


    4、parallel万一报错了咋办?

          lapply在使用的时候也会出现这样的问题,如果出现问题,那么就白跑了,而且也不可能给你停顿下来。那么如何让lapply运行中跳过报错的办法呢?

          R语言相关的报错处理函数可见:R语言-处理异常值或报错的三个示例

          用tryCatch跳过:

    result = tryCatch(
            {expr}, 
            warning = function(w) {warning-handler-code}, 
            error = function(e) { error-handler-code}, 
            finally = {cleanup-code}
            )
    出现warning、error时候怎么处理,就可以跳过了。例子:

    result = tryCatch(
            {segmentCN(txt)}, 
            warning = function(w) {"出警告啦"}, 
            error = function(e) { "出错啦"}, 
            )

    分词时候,容易因为Lapply中断之后,就不会运行了,这样功亏一篑所以可以用这个办法跳过。


    5、parSapply/parLapply函数使用技巧

           函数的大体结构是:

    parSapply(cl,x,fun)

          其中cl是预先设定好的,x是需要循环的变量,而fun是函数。

          那么一般来说,fun之中要使用的任何内容都需要用clusterEvalQ(包)、clusterExport(变量)复制到不同的核心之中。

           而x则可以不用布置到全局,因为他是在源环境下调用出来,并拆分任务的。







    ——————————————————————————————————


    二、foreach包的使用方法


    1、简单使用案例

    设计foreach包的思想可能想要创建一个lapply和for循环的标准,初始化的过程有些不同,你需要register注册集群:

    library(foreach)
    library(doParallel)
    
    cl<-makeCluster(no_cores)
    registerDoParallel(cl)

    要记得最后要结束集群(不是用stopCluster()):

    stopImplicitCluster()

    foreach函数可以使用参数.combine控制你汇总结果的方法:

    > foreach(exponent = 2:4, 
            .combine = c)  %dopar%  
      base^exponent
      [1]  4  8 16
    > foreach(exponent = 2:4, .combine = rbind)  %dopar%   base^exponent
        [,1]
    result.1 4 result.2 8 result.3 16
    foreach(exponent = 2:4, .combine = list, .multicombine = TRUE)  %dopar%   base^exponent
    [[1]]
    [1] 4 [[2]]
    [1] 8 [[3]]
    [1] 16

    注意到最后list的combine方法是默认的。在这个例子中用到一个.multicombine参数,他可以帮助你避免嵌套列表。比如说list(list(result.1, result.2), result.3) :

    > foreach(exponent = 2:4, 
            .combine = list)  %dopar%  
      base^exponent
    [[1]]
    [[1]][[1]]
    [1] 4
    
    [[1]][[2]]
    [1] 8
    
    
    [[2]]
    [1] 16


    2、变量作用域

    在foreach中,变量作用域有些不同,它会自动加载本地的环境到函数中:

    > base <- 2
    > cl<-makeCluster(2)
    > registerDoParallel(cl)
    > foreach(exponent = 2:4, 
            .combine = c)  %dopar%  
      base^exponent
    stopCluster(cl)
     [1]  4  8 16

    但是,对于父环境的变量则不会加载,以下这个例子就会抛出错误:

    test <- function (exponent) {
      foreach(exponent = 2:4, 
              .combine = c)  %dopar%  
        base^exponent
    }
    test()
    
     Error in base^exponent : task 1 failed - "object 'base' not found" 

    为解决这个问题你可以使用.export这个参数而不需要使用clusterExport。注意的是,他可以加载最终版本的变量,在函数运行前,变量都是可以改变的:

    base <- 2
    cl<-makeCluster(2)
    registerDoParallel(cl)
     
    base <- 4
    test <- function (exponent) {
      foreach(exponent = 2:4, 
              .combine = c,
              .export = "base")  %dopar%  
        base^exponent
    }
    test()
     
    stopCluster(cl)
    
     [1]  4  8 16

    相似的你可以使用.packages参数来加载包,比如说:.packages = c("rms", "mice")


    ——————————————————————————————————


    三、SupR

    通过对现有R 内核的改进实现在单机上的多线程和在集群上的分布式计算功能。SupR目前仍处在内部试用和补充完善阶段。


           据说supR很好用,而且小象学院的讲师(游皓麟)已经开始教授这个系统的使用方法,挺好用的。


    ——————————————————————————————————


    四、内存管理


    方法有三:
          一、升级硬件
          二、改进算法
          三、修改操作系统分配给R的内存上限, memory.size(T)查看已分配内存 

    memory.size(F)#查看已使用内存  
    memory.limit()#查看内存上限 
    object.size()#看每个变量占多大内存。
    memory.size()#查看现在的work space的内存使用
    memory.limit()#查看系统规定的内存使用上限。如果现在的内存上限不够用,可以通过memory.limit(newLimit)更改到一个新的上限。注意,在32位的R中,封顶上限为4G,无法在一个程序上使用超过4G (数位上限)。这种时候,可以考虑使用64位的版本。

    详情看:R语言︱大数据集下运行内存管理   以及  R语言之内存管理


    ——————————————————————————————————


    应用一:使用parallel包时,能不能clusterExport整个函数呢?



          R语言在使用Parallel时候,会出现这样的疑问,一些东西都需要广播给不同的核心,那么在clusterExport步骤怎么办呢?能不能clusterExport一整个函数?然后直接parLapply呢?

          答案否定的。笔者在用的时候,怎么样都不能把整个函数加载进去,所以只能另想办法。

          既然不能clusterExport整个函数,那就只能改造我们的函数去适应parallel包了。

          来看几个函数“被”改造的例子,一般来说有两个办法:


    1、方法一:通过.GlobalEnv广播成全局变量

    clusterExport(cl=cl, varlist=c("text.var", "ntv", "gc.rate", "pos"), envir=environment())

          在函数导入的时候,加入envir变量让其广播给不同的核心,这个可以放在函数之中来使用。


    2、方法二:把parLapply嵌套进函数之中

    par.test <- function(text.var, gc.rate=10){ 
        require(parallel)
        pos <-  function(i) {
            paste(sapply(strsplit(tolower(i), " "), nchar), collapse=" | ")
        }
        cl <- makeCluster(mc <- getOption("cl.cores", 4))
        parLapply(cl, text.var, function(text.vari, gc.rate, pos) {
            x <- pos(text.vari)
            if (i%%gc.rate==0) gc()
            x
        }, gc.rate, pos)
    }

           可以看到的这个例子,就是把内容嵌套到parLapply之中了。同时也可以学习到,parLapply使用方法也很不错,也可以学习一下。

          再来看一个例子

    mainFunction <- function(cl) {
        fa <- function(x) fb(x)
        fb <- function(x) fc(x)
        fc <- function(x) x
        y <- 7
        workerFunction <- function(i) {
            do.call(functionNames[[i]], list(y))
        }
        environment(workerFunction) <- .GlobalEnv
        environment(fa) <- .GlobalEnv
        environment(fb) <- .GlobalEnv
        environment(fc) <- .GlobalEnv
        functionNames <- c("fa", "fb", "fc")
        clusterExport(cl, varlist=c("functionNames", functionNames, "y"),
                      envir=environment())
        parLapply(cl, seq_along(functionNames), workerFunction)
    }
    
    library(parallel)
    cl <- makeCluster(detectCores())
    mainFunction(cl)
    stopCluster(cl)

    ——————————————————————————————————

    应用二:在使用parallel包时,报错:Error in unserialize(node$con) : error reading from connection


          在R语言中使用并行算法的时候,会出现报错,无法连接到核心,即使在本来连接上的时候。通过查阅文献看到了,这是因为“调用核心数--计算机内存”的不匹配造成的。

          如果你的数据集很大,调用了很多核心,那么你的计算机内存如果不够匹配,就会出现连接不上的不错,甚至还出现卡机,一动不动的情况(当然,只要耐心等待,其实他还是会继续运行的...等待的时候会有点长)


    解决办法一:调用FORK,window不能...

          FORK适用unix/max,实现内存共享以及节省内存,大数据环境下内存问题报错少

          PSOCK适用所有(一般window都是这个)

          不过调用FORK也还是治标不治本。


    解决办法二:分开并行,小步迭代

          譬如10万数据,那么就“2万+2万+2万+2万+2万”的跑,如果还出现脱机,就用之前tryCatch跳过,让损失降低到最小。

          最好的办法了。



    参考文献:How-to go parallel in R – basics + tips


    ——————————————————————————————————


    参考文献


    1、R语言并行化基础与提高

    2、R与并行计算

    3、sparklyr包:实现Spark与R的接口,会用dplyr就能玩Spark

    4、Sparklyr与Docker的推荐系统实战

    5、R语言︱H2o深度学习的一些R语言实践——H2o包

    6、R用户的福音︱TensorFlow:TensorFlow的R接口

    7、mxnet:结合R与GPU加速深度学习

    8、碎片︱R语言与深度学习

    展开全文
  • 若将detach()改用join(),则不能提高它的计算速度。请问可以通过什么办法解决上述问题? ``` thread CollisionTest[2];//两个线程 for (int t = 0; t ; t++) { CollisionTest[t] = thread(collision, t); ...
  • spark 并行计算模型

    万次阅读 2012-12-19 23:04:32
    Spark Spark是一个小巧玲珑的项目,由...Spark要解决的问题是,在当前的分布式计算框架中不能有效处理的两类问题:iterative(迭代计算)和 interactive(交互式)计算。 目前最流行的Hadoop 系统实现了DAG(有向无环
  • 1.解决并行计算中同步时间的问题 异步的梯度下降,这个算法本身跟梯度下降是一样的,从理论收敛率来看,异步算法需要更多的迭代次数,比同步算法慢,但是实际实现时,异步算法避免了同步造成的时间浪费,实际上比...
  •  Fourinone对于分布式大数据量并行计算的解决方案不同于复杂hadoop,它像hadoop中间计算结果依赖于hdfs,它使用不同于map/reduce全新设计模式解决问题。Fourinone有“包工头”,“农民工”,“手工仓库”...
  • 数据倾斜是在大数据计算中常见的问题,用最通俗易懂的话来说,数据倾斜无非就是大量的相同key被partition分配到一个分区里,造成了'一个人累死,其他人闲死'的情况,这种情况是我们不能接受的,这也违背了并行计算的初衷,...
  • 出现此问题是因为您计算机中缺少VC运行库导致,建议您到互联网上下载相应VC2005运行库,Windows 7请下载VC2008运行库安装到您计算机中。如果您安装了运行库还是不行,建议您安装:...
  • 随着数据爆炸式增长,传统算法已不能适应大数据挖掘需要,需要分布式、并行关联规则挖掘算法来解决上述问题。MapReduce是一种流行分布式并行计算模型,因其使用简单、伸缩性好、自动负载均衡和自动容错等...
  • 每一次遇到问题解决问题都是一种锻炼,一种尝试,从我们上并行计算课我懂得了很多电脑硬件和软件知识,这些可能对于我们这个专业以后都是没有机会接触,所以我觉得选择了并行计算与多核多线程技术这门课是非常...
  • Disruptor是英国外汇交易公司LMAX开发一个高性能队列,研发初衷是解决内部内存队列延迟问题,而不是分布式队列。基于Disruptor开发系统单线程支撑每秒600万订单,2010年在QCon演讲后,获得了业界关注。 ...
  • 每一次遇到问题解决问题都是一种锻炼,一种尝试,从我们上并行计算课我懂得了很多电脑硬件和软件知识,这些可能对于我们这个专业以后都是没有机会接触,所以我觉得选择了并行计算与多核多线程技术这门课是非常...
  • TSP 问题的解空间随着问题规模增大而迅速膨胀,面对大规模TSP 问题庞大搜索空间,单个计算机的计算能力已经远不能满足搜索算法对时间要求. 并行算法求解大规模TSP 问题越来越受到研究者关注,出现了并行蚁群...
  • 本文提出了一种新颖且有效的并行两列表算法的实现使用Compute Unified Device Architecture解决图形处理单元(GPU)上的问题的方法(CUDA)。 该算法由生成阶段,修剪阶段和搜索阶段组成。 它是在GPU上有效地实现...
  • 天下没有免费午餐,性能免费大餐也不能毫无止境,实际上,已经有了新的解决方案并行计算并行计算就像是一道饕餮大餐而被人津津乐道,在本文中我们以烹饪为类比,通过对性能免费大餐分析,使用 Visual
  • 的问题已经写在压缩包的word文档中,是关于abaqus与Fortran关联出现error的问题。此问题与常规的subroutine通过不同,我没有找到解决办法,只能求助于您。相关文件也已附上,请您查收。如需提供其他文件请您联系...
  • 给定带灵活通配符模式和文本,目标是在线的计算模式在文本中出现次数和匹配位置,这里要求任何两次出现不能共享文本同一位置,即One-Off条件。提出了一个基于位并行的搜索算法,采用了非确定有限自动机...
  • 最近研究gearman时发现不少问题,关于队列持久化的问题搞了半个月还是没能解决,并且国内可以参考的资料太少,所以考虑换一种方案试试。如下贴出gearman集群的架构: 可以看到该架构存在的问题,当持久化起...
  • 程序是写出来了,而且cpu占用率为0,但是有个缺点,不能和MFCpicture控件绑定,我把窗口picture控件句柄传给Yuv表面了,拖动会晃动,还且怎是在最上层,郁闷,如果谁知道这个问题的解决办法,欢迎给我留言,...
  • MapReduce数据倾斜问题的解决方案

    千次阅读 2018-05-11 13:24:07
    MapReduce数据倾斜问题解决方案,在并行计算中我们总希望分配每一个task 都以差不多粒度来切分并且完成时间相差不大,但是集群中可能硬件不同,应用类型不同和切分数据大小一致总会导致有部分任务极大...
  • 在使用并行循环冗余校验(Cyclical Redundancy Check,CRC)时会有一个问题,即需要计算CRC数据域长度一定是数据通道位宽整数倍,导致最后一组数据无法使用数据通道位宽对其进行CRC计算。为了解决这个问题,...
  • 它们只能部分显示图像字符,不能客观提取。 卷积神经网络(CNN)是一种人工神经网络,已经成为当前图像分类研究重点。 基于CNN深度学习可以自动提取图像特征。 为了提高图像分类性能,提出了一种结合了CNN和并行...
  • 另一方面,从计算效率角度来看,由于搜索空间激增,单线程方法通常不能处理大量候选服务。 本文共同解决了这两个问题,即大规模,基于QoS服务组合产生了top-k解决方案。 合成算法基于回溯搜索和深度优先...
  • 虽然早就有人提出了让并行计算架构GPU,去处理非常适合他们大规模并行计算工作,但是在CUDA问世前,所谓GPGPU概念并没有真正为我们解决问题,而早期专为图形运算而设计GPU并不能通过一种通用性强手段...
  • 作为GIS核心功能之一,空间分析逐步向处理数据海量化及分析过程复杂化方向发展,以往串行算法渐渐不能满足人们对空间分析在计算效率、性能等方面需求,并行空间分析算法作为解决目前问题的有效途径受到越来越...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 303
精华内容 121
关键字:

并行计算不能解决的问题