小编Pro*_*ala的帖子

简而言之

每次我对模块代码进行一些更改时，如何强制 python 解释器加载模块的最新代码版本？

或者至少通过键入重新加载最后修改的版本

>>> from myModule import *

进入控制台，无需重新启动整个 python 控制台并在我进行一些更改时一次又一次地设置所有内容？这对于调试来说是极其不愉快的行为。

--------- 更长的故事 -----------

我尝试删除 .pyc 文件，然后再次导入它 - 但没有效果。它甚至不会再次创建 .pyc 文件 - 所以我希望如果模块已经加载，它会完全忽略我的“导入”命令。

这也没有帮助：

>>> mymodule.myfunc()    # the old version
>>> del myModule         # unload mymodle from python conole / interpeter
...                  # now I removed .pyc
...                  # now I make some modifications in mymodule.myfunc() code   
>>> mymodule.myfunc()    # module is unknonwn, ... OK
>>> import myModule      # try to load modified version
>>> mymodule.myfunc() …

如何使用 CMake 将资源从源目录复制到构建目录的最简单方法是

file( COPY ${CMAKE_CURRENT_SOURCE_DIR}/resources DESTINATION ${CMAKE_CURRENT_BINARY_DIR} )

但是，这仅在我调用cmake. 我需要每次调用时 更新资源的东西make。

例如，现在我开发了一些 GLSL 着色器。我需要同时更改 C++ 代码和 GLSL 代码，并且每次点击 compile或run在我的 IDE 中都需要同步所有内容（我使用 CodeBlocks 和 CMake 生成的项目文件）

简单的解决方案是制作从源目录到构建目录的软链接。但我不想手动完成（这将绕过 CMake 并使项目更加脆弱）。CMake 可以为我做吗？

只是为了完整，这就是我的整体的CMakeList.txt样子

# ==== common header

cmake_minimum_required ( VERSION 2.8 )
project ( SimpleSimulationEngine )

if( UNIX )
    SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -std=gnu++0x" )
endif()

SET( AXULIARY_COMPILE_FLAGS "-w -O2")
SET( CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} …

我正在学习如何优化GPU的代码.我读到了记忆局部性的重要性.我也看过一些GPU卷积的教程和例子.基于此,我编写并测试了几个自己的内核.令人惊讶的是,我发现最简单的天真kernell是最快的!？它比CPU快10倍.(是的,我通过运行kenrnel 64x分摊上传/下载时间).

我做错了什么？我希望卷积只是GPU优化的那种操作.如果我可以在矩阵乘法上获得100倍的加速,为什么卷积是如此之慢？

• CPU天真 9.5
• GPU天真 1.64
• GPU本地 2.56
• GPU-local_async 15.10
• GPU-scanline-private 7.35
• GPU-scanline_async 15.37

编辑:GPU-scanline_async我在阅读了有关的建议之后做了async_work_group_copy

我想知道两件事:

• 内核速度是受内存带宽还是计算能力限制的？根据我的阅读,我期待记忆.但测试结果显示相反的结果.
  • 内核GPU本地比GPU更低,即使它的全局内存读取少得多
  • 通过高斯滤波器系数修改内核(即每个像素增加乘法)使其速度降低2倍,尽管它具有相同数量的内存读取
  • 但是,如果它受到处理能力的限制,那么为什么我在GPU上的矩阵乘法比在CPU上快100倍？
• 内核GPU-scanline-private为何如此之慢？内存位置要好得多(每个像素只有3个而不是全局内存中的9个读取)并且逻辑很小(没有ifs/switches)

测试是在我的笔记本电脑上使用CPU Intel Core i7 6700HQ Skylake和GPU nVidia 960M在256x256像素的浮点阵列上运行内核64x /帧.完整的代码可以在这里看到.

===========内核代码===========

内核 GPU-Naive 2D global =(256,256)local =(16,16)

__kernel void blur2D_naive(
    __global float* I, 
    __global float* O
){
    const …

我正在尝试学习如何制作GPU优化的OpenCL kernells,我在本地存储器中使用方形图块作为矩阵乘法的例子.然而,与numpy.dot()(5 Gflops,它正在使用BLAS)相比,我获得了最好的情况只有~10倍的加速(~50 Gflops).

我发现他们的研究速度超过200倍(> 1000 Gflops). ftp://ftp.u-aizu.ac.jp/u-aizu/doc/Tech-Report/2012/2012-002.pdf 我不知道我做错了什么,或者只是因为我的GPU(nvidia GTX 275).或者,如果是因为一些pyOpenCl开销.但是我也确信将GPU的结果复制到RAM需要多长时间,它只是矩阵乘法时间的10%左右.

#define BLOCK_SIZE 22 
__kernel void matrixMul(
      __global float* Cij, 
      __global float* Aik, 
      __global float* Bkj, 
      __const int ni, 
      __const int nj,
      __const int nk
){
//   WARRNING : interchange of  i  and  j  dimension  lower the performance >2x on my nV GT275 GPU    
int gj = get_global_id(0);    int gi = get_global_id(1); 
int bj = get_group_id(0);     int bi = get_group_id(1);  // Block index
int …

我正在从 python/numpy 迁移到 julia。我真的对 Julia 的多维数组感到困惑，感觉有一些额外的复杂性/麻烦（与 numpy 相比）。

1) 行向量、2) 列向量、3) 多维数组和 4) 嵌套数组（=数组的数组）之间存在区别。假设有一种简单的方法可以在它们之间进行转换，那就没问题了（也许对性能优化有用）。但我不知道该怎么做。

简单的例子： \n我只是尝试生成点的二维矩形网格并绘制它们

\nps = [ [ix*0.1 iy*0.1] for ix=1:10, iy=1:10 ]\n# 10\xc3\x9710 Array{Array{Float64,2},2}:\n# Oh, this is nested array? I wand just simple 3D array 10x10x2\n\nscatter( ps[:,:,1], ps[:,:,2], markersize = 2, markerstrokewidth = 0, aspect_ratio=:equal )\n# ERROR: BoundsError: attempt to access 10\xc3\x9710 Array{Array{Float64,2},2} at index [Base.Slice(Base.OneTo(10)), Base.Slice(Base.OneTo(10)), 2]\n\nsh = size(ps)\n# (10,10)\n\nps = reshape( ps, ( sh[1]*sh[2],2) )\n# ERROR: DimensionMismatch("new dimensions (100, 2) must be …

这是关于良好做法的问题

考虑典型的情况,例如在3D引擎,物理引擎,有限元方法或经典分子动力学求解器中:您有各种类型的对象(例如顶点,边,面,有界实体体积)彼此交叉链接(例如顶点知道哪个边连接到它,反之亦然).对于这种引擎的使用性能和便利性,能够快速浏览这种连接的网络是至关重要的.

问题是:通过数组中的索引或指针指向链接对象是否更好？......特别是在表现方面

typedef index_t uint16_t;

class Vertex{
    Vec3 pos;
    #ifdef BY_POINTER
    Edge*   edges[nMaxEdgesPerVertex];
    Face*   faces[nMaxFacesPerVertex];
    #else
    index_t edges[nMaxEdgesPerVertex];
    index_t faces[nMaxFacesPerVertex];
    #endif
}

class Edge{
    Vec3   direction;
    double length;
    #ifdef BY_POINTER
    Vertex* verts[2];
    Faces*  faces[nMaxFacesPerEdge];  
    #else
    index_t verts[2];
    index_t faces[nMaxFacesPerEdge];
    #endif
}

class Face{
    Vec3   normal;
    double isoVal; // Plane equation: normal.dot(test_point)==isoVal
    #ifdef BY_POINTER
    Vertex* verts[nMaxVertsPerFace];
    Edge*   edges[nMaxEdgesPerFace];
    #else
    index_t verts[nMaxVertsPerFace];
    index_t edges[nMaxEdgesPerFace];
    #endif
}

#ifndef BY_POINTER
// we can use …

我读过 GPU 上的比较和分支很慢。我想知道多少钱。（我对 OpenCL 比较熟悉，但这个问题对于 CUDA、AMP 来说也很普遍……）

在我开始将代码移植到 GPU 之前，我想知道它。特别是我有兴趣在二维数组中的每个点的邻域（4 或 9 个最近邻）中找到最小值。即类似于卷积的东西，但我需要比较和分支而不是求和和相乘。

例如这样的代码（注意：此示例代码尚未针对 GPU进行优化以使其更具可读性......因此分区到工作组，预取本地内存......丢失）

for(int i=1;i<n-1;i++){ for(int j=1;j<n-1;j++){ // iterate over 2D array
     float hij  = h[i][j];
     int imin = 0,jmin = 0;
     float dh,dhmin=0;
     // find lowest neighboring element h[i+imin][j+jmin] of h[i][j]
     dh = h[i-1][j  ]-hij;  if( dh<dhmin ){  imin = -1; jmin =  0; dhmin = dh; }
     dh = h[i+1][j  ]-hij;  if( dh<dhmin ){  imin = +1; jmin …

C ++的常见做法是将.h（或.hpp）中的声明和实现分隔为.cpp。

我知道两个主要原因（也许还有其他原因）：

1. 编译速度（仅更改一个文件就不必重新编译所有文件，可以通过make预编译的.o文件进行链接）
2. 前向声明有时是必需的（当执行class Adepends class B和class Bon时class A ）...但是我没有那么多问题，通常我可以解决它。

对于面向对象的编程，它看起来像这样：

QuadraticFunction.h：

class QuadraticFunc{
    public:
    double a,b,c;
    double eval ( double x );
    double solve( double y, double &x1, double &x2 );
};

QuadraticFunction.cpp：

#include <math.h>
#include "QuadraticFunc.h"

double QuadraticFunc::eval ( double x ){ return c + x * (b + x * a ); };

double QuadraticFunc::solve( double y, double …

解决方案很明显,但这是一个很好的解决方案的问题.

(编辑:很好,我的意思是例如1)没有代码减少2)没有压缩性能3)而不强迫程序员做一些不必要的函数或临时变量)

考虑情况的时候,我想这取决于数字来执行3个不同的代码块a,b,c是最小的.

代码如下所示:

    if( a < b ){
       if( a < c ){  
           // code block for "a is minimum" case
       }else{        
           // code block for "c is minimum" case
       }
    }else{
       if( b < c ){
           // code block for "b is minimum" case
       }else{    
           // code block for "c is minimum" case
       }
    }

我不喜欢的是我必须复制// code block for "c is minimum" case两次.

有几种解决方案.例如,我可以将代码块"c is …

我正在尝试在 WebGL2 中使用浮点纹理。我像这样初始化纹理：

function textureFromFloat32Array( gl, arr, w, h ){
    //https://developer.mozilla.org/en-US/docs/Web/API/OES_texture_float_linear
    gl.getExtension('OES_texture_float');        // just in case
    gl.getExtension('OES_texture_float_linear'); // do I need this with WebGL2
    const texture = gl.createTexture();
    gl.bindTexture( gl.TEXTURE_2D, texture);
    // see https://www.khronos.org/registry/webgl/specs/latest/2.0/#TEXTURE_TYPES_FORMATS_FROM_DOM_ELEMENTS_TABLE
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.R32F, w, h, 0, gl.RED, gl.FLOAT, arr);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
    //gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); // this works
    //gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    return texture;
}

在 Firefox 55.0.2（64 位）中，出现以下错误：

Error: WebGL warning: drawElements: Active texture 0 for target …