主页 / user-17567231

PkDrew's questions

Martin Hope
PkDrew
Asked: 2025-04-16 15:14:27 +0800 CST
  • 6

该代码给出了编译器错误：“期望一个表达式”。

std::array< std::string, 3 > candidates = useOutname ? { "%O.log", "%O_.log", "_%O.log" } : { "%J.log", "%J_.log", "_%J.log" };

如果更改为普通的 if else 语句，则它可以起作用：

std::array< std::string, 3 > candidates;
if (useOutname) {
    candidates = { "%O.log", "%O_.log", "_%O.log" };
}
else {
    candidates = { "%J.log", "%J_.log", "_%J.log" };
}

我想知道为什么使用三元运算符会导致错误？是因为花括号初始化吗？

c++
Martin Hope
PkDrew
Asked: 2025-03-08 13:00:22 +0800 CST
  • 6

下面的代码总是在任何其他内容之前打印出“Hello from the start”，而在任何其他内容之后打印出“Hello from the end”，这是为什么呢？

代码：

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <iostream>

#include "cuda_runtime.h"
#include "device_launch_parameters.h"


__global__ void add1InGPU( int *devArr, int n, int nx )
{
    int ix = blockIdx.x * blockDim.x + threadIdx.x;
    int iy = blockIdx.y * blockDim.y + threadIdx.y;
    int id = nx * iy + ix;

    int whateverNum = 5;

    if (id == whateverNum) printf("Hello from the start\n");
    
    if ( id < n ) {
        devArr[id] += 1; 
        printf("blockIdx.x: %d, threadIdx.x: %d, blockIdx.y: %d, threadIdx.y: %d, processing index %d\n", blockIdx.x, threadIdx.x, blockIdx.y, threadIdx.y, id );
    }
    else {
        printf("blockIdx.x: %d, threadIdx.x: %d, blockIdx.y: %d, threadIdx.y: %d, skipped\n", blockIdx.x, threadIdx.x, blockIdx.y, threadIdx.y);
    }

    if (id == whateverNum) printf("Hello from the end\n");
}

int main(void)
{
    
    int* d_arr = NULL;
    cudaMalloc(&d_arr, 16 * sizeof(int));
    cudaMemset(d_arr, 0, 16 * sizeof(int));

    int nElem = 16;
    dim3 block( 2, 2 );
    dim3 grid( 2, 2 );
    // dim3 grid( ( nElem + block.x - 1 ) / block.x );
    
    add1InGPU<<<grid, block>>> ( d_arr, nElem, 4 );
    cudaDeviceSynchronize();
    int *h_arr = (int*)malloc(16 * sizeof(int));
    cudaMemcpy(h_arr, d_arr, 10 * sizeof(int), cudaMemcpyDeviceToHost);
    cudaFree(d_arr);

    volatile int _ = 0;
    for (int i = 0; i < 10; i++) {
        _ += h_arr[i];
    }

    cudaDeviceReset();
    
    return 0;
}

输出：

Hello from the start
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 0, processing index 2
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 0, processing index 3
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 1, processing index 6
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 1, processing index 7
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 0, processing index 8
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 0, processing index 9
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 1, processing index 12
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 1, processing index 13
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 0, processing index 10
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 0, processing index 11
blockIdx.x: 1, threadIdx.x: 0, blockIdx.y: 1, threadIdx.y: 1, processing index 14
blockIdx.x: 1, threadIdx.x: 1, blockIdx.y: 1, threadIdx.y: 1, processing index 15
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 0, processing index 0
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 0, processing index 1
blockIdx.x: 0, threadIdx.x: 0, blockIdx.y: 0, threadIdx.y: 1, processing index 4
blockIdx.x: 0, threadIdx.x: 1, blockIdx.y: 0, threadIdx.y: 1, processing index 5
Hello from the end
c++
Martin Hope
PkDrew
Asked: 2024-12-22 16:09:27 +0800 CST
  • 7

假设我有一个名为的结构体Particle，我想让它按 32 位对齐，alignas我在指定结构体定义时是否应该使用关键字，如下面的代码：

struct alignas(32) Particle {
    // Total size: 16 bytes, but alignas(32) ensures 32-byte alignment
    float x; // 4 bytes
    float y; // 4 bytes
    float z; // 4 bytes
    float w; // 4 bytes 
};

或者我应该在结构所在的布局定义中指定它，如下所示：

alignas(32) Particle particles[8]; // Array of 8 particles, 32-byte aligned

或者我应该两者都做？

c
Martin Hope
PkDrew
Asked: 2024-12-21 09:08:36 +0800 CST
  • 6

在我的开发环境中，存在一个将标准输出写入特定文件的别名。

它使用带三通的管道，例如du -h | & tee /tmp/diskUsage。

我理解 AND 运算符会使其前面的内容成为文件描述符而不是文件名，比如2>&1我们将 stderr 重定向到 stdout，而不是当前目录中名为“1”的文件。

但是，对于用法来说| & tee，在'&'之后和“tee”之前没有任何有意义的内容，在这种情况下它起什么作用？

linux
Martin Hope
PkDrew
Asked: 2024-12-12 22:15:09 +0800 CST
  • 6

我最近正在学习一些 HPC 主题，并且了解到现代 C/C++ 编译器能够检测有权进行优化的地方，并使用相应的技术（如 SIMD、循环展开等）进行优化，尤其是在标志下-O3，在运行时性能与编译时间和目标文件大小之间进行权衡。

然后我立即想到 CPython 是即时解释和执行的，所以我认为它无法承担这些编译器功能，因为它的编译时间相当于运行时，所以我做了下面的一个玩具实验：

import time, random

n = 512
A = [[random.random() for _ in range(n)] for _ in range(n)]
B = [[random.random() for _ in range(n)] for _ in range(n)]
C = [[0] * n for _ in range(n)]

def matMul( A, B, C ):
    """ C = A .* B """
    for i in range(0, n - 4, 4):
        for j in range(0, n - 4, 4):
            for k in range(0, n - 4, 4):
                C[i][j] = A[i][k] * B[k][j]
                C[i + 1][j + 1] = A[i + 1][k + 1] * B[k + 1][j + 1]
                C[i + 2][j + 2] = A[i + 2][k + 2] * B[k + 2][j + 2]
                C[i + 3][j + 3] = A[i + 3][k + 3] * B[k + 3][j + 3]
                C[i + 4][j + 4] = A[i + 4][k + 4] * B[k + 4][j + 4]
    # return C

start = time.time()
matMul( A, B, C )
end = time.time()

print( f"Elapsed {end - start}" )

循环展开后，程序在 3 秒内完成，如果不展开，则需要将近 20 秒。

这是否意味着在编写 Python 代码时需要注意并手动实现这些 opt 技术？或者 Python 是否在任何特殊设置下提供优化？

python
Martin Hope
PkDrew
Asked: 2024-12-09 18:26:00 +0800 CST
  • 6

我最近了解到 fork 甚至在寄存器上也应用 COW（写时复制）。

我玩了一个简单的玩具盒来验证：

(gdb) info inferiors
  Num  Description       Connection           Executable
* 1    process 59316     1 (native)           /home/Drew/mycode/a.out
  2    process 59386     1 (native)           /home/Drew/mycode/a.out
(gdb) print( $rdi )
$1 = 18874385
(gdb) set $rdi=42
(gdb) print( $rdi )
$2 = 42
(gdb) inferior 2
[Switching to inferior 2 [process 59386] (/home/Drew/mycode/a.out)]
[Switching to thread 2.1 (process 59386)]
#0  0x00002aaaab090291 in fork () from /lib64/libc.so.6
(gdb) print( $rdi )
$3 = 18874385

正如你们看到的，修改父进程中的 rdi 不会干扰子进程。

我想知道它是怎么做到的？现代 CPU 是否专门为多进程提供多个相同的寄存器？

编辑：

感谢各位的评论。我会在这里集体回答评论中的问题，希望这有助于澄清。

我正在使用的参考资料是这份讲稿。

我一般想弄清楚：

  • 无论是否是 COW，Linux 是否会复制寄存器？
  • 如果答案是肯定的，那么它是由硬件完成的，即 CPU 制造商提供设计支持，就像他们支持虚拟机一样，或者由软件完成，比如说，操作系统将寄存器值存储在某处（在 RAM 中？），因此，它不是对寄存器本身进行操作，而是有效地修改页面，但以某种方式设法模仿寄存器行为？
  • 如果 fork 不以任何方式复制寄存器，为什么我会在 GDB 中看到这种现象？
c
Martin Hope
PkDrew
Asked: 2024-12-01 16:55:30 +0800 CST
  • 9

我想知道为什么下面的代码打印“错误”。

double x = 0x8000000000000000;
signed long long v1 = (signed long long)(x);
signed long long v2 = *(signed long long *)(&x);
printf( v1 == v2? "correct\n" : "wrong\n" );

我尝试通过以下代码分别打印出 v1 和 v2 的二进制表示形式：

printf( "v1 = 0b" );
for ( int i = 63; i > 0; i-- ) {
    printf( "%d", ( ( v1 >> i ) & 1 ) );
}
printf( "\n" );

printf( "v2 = 0b" );
for ( int i = 63; i > 0; i-- ) {
    printf( "%d", ( ( v2 >> i ) & 1 ) );
}
printf( "\n" );

事实证明 v1 是正确的，但 v2 是0b010000111110000000000000000000000000000000000000000000000000000。

有谁能好心地告诉我这里发生了什么吗？

另外，我想知道 C 标准是否提供了任何打印出二进制或十六进制底层表示的方法，以便我的打印方案可以用一行函数调用来代替？

c
Martin Hope
PkDrew
Asked: 2024-11-19 20:11:55 +0800 CST
  • 5

如果 nth 超出范围 [first, last)，我找不到任何与处理 std::nth_element(first, nth, last) 相关的官方定义。

为了弄清楚这一点，我对我的机器进行了一个玩具测试：

std::vector<int> arr{ 7, 3, 9, 6, 4 };
std::nth_element( arr.begin() + 1, arr.begin(), arr.end() );
for (int num : arr) {
    printf("%d", num);
}

MSVC 在 vector 的 stl src 代码中给出断言失败，提示“vector iterator range transposed”。这是未定义的行为吗？

c++
Martin Hope
PkDrew
Asked: 2024-11-14 21:20:04 +0800 CST
  • 6

假设现在我已经为 unordered_set 准备好了 hash 和 equal 函数

auto equalFunc = [](...){...};
auto hashFunc  = [](...){...};

如果单独使用 unordered_set，我知道我可以执行以下操作来指定我的 DIY 哈希和相等：

std::unordered_set<std::pair<int,int>, decltype( hashFunc ), decltype( equalFunc )> mySet( 0, hashFunc, equalFunc );

但是，现在假设 unordered_set 要用作 std::unordered_map 的值，我该如何指定哈希和相等？

std::unordered_map<int, std::unordered_set<std::pair<int,int>, decltype( hashFunc ), decltype( equalFunc )>> myMap( ...how? );
c++
Martin Hope
PkDrew
Asked: 2024-09-23 09:26:41 +0800 CST
  • 7

在 GDB 中我可以执行以下操作并获取字符串文字的地址：

(gdb) p &"aaa"
$3 = (char (*)[4]) 0x614c20

据我了解，字符串文字是一个没有绑定符号的右值，但为什么我可以获取它的地址？

这是什么样的地址？它是存储所有字符串文字的地方吗？但是字符串文字是无限的，这是否意味着字符串文字是按需“创建并放入内存”的？

c++
Martin Hope
PkDrew
Asked: 2024-08-24 16:53:51 +0800 CST
  • 4

假设我有一个任意容器，并询问其中是否有一个元素，如下所示。

D = {(1, 2): "whatever"}
if (2, 1) in D:
    print( "Impossible" )

就底层代码而言，到底发生了什么？是否调用了任何特定的成员函数（例如 find()）？

此外，我可以使用定制的 cmp/hash 吗？比如说，如果我只想比较元组的键中每个数字的出现次数，如代码片段所示，我该怎么做才能实现呢？

D = {(1, 2, 1): "whatever"}
if (2, 1, 1) in D:
    print( "As expected" ) # How to make it happen?

如果能提供一份官方的 Py 文档我将非常感激，我认为这是相当基础的信息，但在任何地方都找不到官方介绍。

python
Martin Hope
PkDrew
Asked: 2024-08-13 16:32:26 +0800 CST
  • 5

在 Linux 中（不确定是否适用于 Windows，任何相关知识都值得赞赏），当只需要一小部分共享库时，使用一种名为延迟绑定的技术来提高性能，想象一下当您使用 -h --help arg 等调用程序时。

我想知道它是如何实现的？它是否与操作系统虚拟内存管理的惰性分配技术有关？即，不是将所有指令加载到内存中，而是首先进行到未映射内存的映射，并且仅在运行时真正需要/引用时才加载有效内存。

linux