小编dan*_*ter的帖子

所以我一直在编写一个程序,它使用曲面细分着色器和高度图来绘制环境.它以32x32平面开始,当它得到更多细分时,每个方形顶点的高度由高度图确定.

我想要它,以便补丁越接近相机,它得到的细分越多.但是,我发现这会导致补丁之间的差距.如果补丁的镶嵌细分比旁边的补丁更多,则不同的分辨率会导致间隙.

在这里,一张图片胜过千言万语:

如果两个补丁具有相同的分辨率,则没有间隙.我怎样才能解决这个问题？我完全卡住了.

所以我正在练习一些编程面试问题,并偶然发现了这个样本pdf,它推荐"了解如何使用蒙版并以独立于机器的方式创建它们".但它没有阐明机器相关和机器独立掩模之间的区别.

我通常只计算出提供我想要的掩码的整数,例如,如果我只想要最后4位,我会做:

int y = x & 15;

我不明白为什么这会依赖于机器,如果是的话.

那么创建一个与机器无关的掩码的例子是什么？什么是创建依赖于机器的掩码的示例？

也许他们正在谈论的是如果你需要一个不是整数的东西的掩码,在这种情况下我的方法是行不通的(除了整数之外我什么都不需要掩码)？

我想,答案是在完成所有初始组件大小调整之后,但请看一下这个SSCCE:

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Test2 {

  private static void createAndShowGUI2() {

    final JFrame frame = new JFrame("Test2");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    JButton addSecondListener = new JButton("Click me to add a second listener");
    addSecondListener.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        frame.addComponentListener(new ComponentAdapter() {
          public void componentResized(ComponentEvent e) {
            System.out.println("Component Listener 2");
          }
        });
      }
    });

    frame.getContentPane().add(addSecondListener);

    frame.setSize(200, 200);
    frame.setVisible(true);

    frame.addComponentListener(new ComponentAdapter() {
      public void componentResized(ComponentEvent e) {
        System.out.println("Component Listener 1");
        //throw new NullPointerException("Just getting traceback...");
      }
    });

  } …

我的Cuda程序获得了显着的性能提升(平均),具体取决于块的大小和块数; 其中"线程"的总数保持不变.(我不确定线程​​是否是正确的术语......但我将在这里使用它;每个内核的总线程数是(块数)*(块大小)).我制作了一些图表来说明我的观点.

但首先让我先解释一下我的算法是什么,但我不确定它是多么相关,因为我认为这适用于所有GPGPU程序.但也许我错了.

基本上我会遇到逻辑上被视为2D数组的大型数组,其中每个线程从数组中添加一个元素,并将该值的平方添加到另一个变量,然后在最后将值写入另一个数组,其中每个读取所有线程都以某种方式移位.这是我的内核代码:

__global__ void MoveoutAndStackCuda(const float* __restrict__ prestackTraces, float* __restrict__ stackTracesOut,
  float* __restrict__ powerTracesOut, const int* __restrict__ sampleShift,
  const unsigned int samplesPerT, const unsigned int readIns,
  const unsigned int readWidth, const unsigned int defaultOffset) {

  unsigned int globalId = ((blockIdx.x * blockDim.x) + threadIdx.x); // Global ID of this thread, starting from 0 to total # of threads

  unsigned int jobNum = (globalId / readWidth); // Which array within the overall program this thread works on …

我想要一种具有“全局预处理器定义”的方法，以便我可以在编译之前更改单个值以添加或删除程序的功能。目前我有一个“全局脚本”（称为 God.cs），其常量如下：

public const bool PRINT_RUN_VALUES = true;
public const bool DEBUG_MOVEMENT = false;
public const bool DOUBLE_SPEED = false;

所有相关脚本都使用这些值，例如：

在脚本1中：

if (God.PRINT_RUN_VALUES) {
   float averageDist = /* calculate values */
   print("Script1: averageDist = " + averageDist);
}

在脚本2中：

if (God.PRINT_RUN_VALUES) {
   print("Script2: radius = " + radius);
   print("Script2: time = " + time);
}

这种方法的问题是我得到了很多

CS0162：检测到无法访问的代码

警告。我可以使用以下方法关闭这些警告：

#pragma warning disable 0162
#pragma warning disable 0429

但我不想这样做，因为这些警告在不涉及 God.cs 中的这些值的情况下可能很有用。另一种方法可能是使用经典的预处理器定义，例如：

#define PRINT_RUN_VALUES
...
#if (PRINT_RUN_VALUES)
   float averageDist = /* calculate …

所以我使用 C 语言和 64 位机器编写了一个测试下溢和溢出的小实验。对于 int 类型，最小/最大值为：

   int tmax = 2147483647;
   int tmin = -2147483648;

我知道二进制补码是如何工作的，这不是我的问题。

所以我想，如果我做了一些负面的事情会发生什么？那是：

   int tmin = -2147483648;
   int negativeTmin = -tmin;

结果还是tmin。（也就是说，负Tmin将为-2147483648）

我的问题是为什么会这样？由于正 2,147,483,648 不能用 int 表示，我理解为什么它当然不是这样，但它根本没有改变似乎很奇怪，因为这使得它成为应用 - 时唯一不会改变的非零 int到它。我并不是说我对它应该是什么有更好的了解，我只是好奇为什么 -tmin == tmin。它是否与按位运算有关，或者与计算机中如何进行减法有关，或者它是否默认这样做，因为我想要做的事情是未定义的，或者其他什么？

我的代码：

#include <stdio.h>
int main() {
   int tmax = 2147483647;
   printf("tmax Before: %d\n", tmax);
   tmax++;
   printf("tmax After: %d\n\n", tmax);

   int tmin = -2147483648;
   printf("tmin Before: %d\n", tmin);
   tmin--;
   printf("tmin After: %d\n\n", tmin);

   int tmin2 = -2147483648;
   int negativeTmin = -tmin2;
   printf("negative tmin: …