全部问题(coding)

TL;DR：许多资料都提到，过度内联函数有时会因为代码膨胀或其他因素而损害应用程序性能。有没有一个实际的程序示例可以以可衡量的方式证明这一点？

记住，微基准测试的使命是放大程序性能的某些方面。正因如此，任何人都可以轻松生成一个微基准测试，让任何特定问题看起来都像是大问题。// Rico Mariani 的性能花絮

我接触过的许多程序员都认为函数内联对应用程序性能绝对有益。我经常审查的 C/C++ 代码中，函数内联inline（或类似的）关键字被随意地应用于函数，无论其大小、用途、热度或位置如何。

很多情况下，这种奇怪的习惯（这里称之为“内联病” ）对整体性能并无害：现代编译器对于哪些代码需要内联有着很好的判断能力，而且很少有代码会因为热度高到让（非）内联产生任何影响。然而，它往往会对最终的软件设计造成损害：更多内容最终会堆积在头文件中，文件不再能够独立编译，等等。

虽然很容易证明，在没有连续基准测试的情况下应用随机内联不会对最终性能产生任何可衡量的差异，但我正在寻找一个极端的例子，强制执行该问题会严格损害性能。

微基准测试就足够了；虽然它无法证明内联对实际应用的任何影响，但它应该能够证明，盲目地强制执行内联并非无条件的好主意。这实际上是几乎所有代码优化过程背后的想法：它可能有帮助，也可能有害，有时甚至没有区别。

此类示例微基准测试的一些要求。

1. 它应该是一个相当短的程序，最好是用 C 或 C++ 编写的；其他可以强制内联的语言也欢迎。
2. 它不必是执行任何有用操作的程序，它可能会做一些“愚蠢”的事情只是为了加载/强调底层硬件。
3. 应该支持两种编译模式：强制内联和禁用内联。可以使用任何技术来实现：条件编译来重新定义内联注解，编译器后端标志来控制内联等等。
4. 无论在哪一种模式下进行编译，它都应该格式良好并表现出相同的明确定义的行为。
5. 它应该包含至少两个函数，一个调用另一个函数，目的是影响其中至少一个函数的内联。
6. 它可能包含任何保证/强制函数内联的技术。例如，可以使用标准inline关键字或编译器特定的扩展（__forceinline等__attribute__ ((always_inline))）来指示编译器执行此操作，无论其判断如何。
7. 运行时，可以轻松报告性能（延迟、执行时间或类似指标）。它可以仅使用time a.out，也可以在受影响的代码周围内部调用计时工具。
8. 最后，当由特定版本中的至少一个特定编译器进行编译并在至少一个目标系统上运行时，所得到的程序的两个变体表现出统计上的显著差异，并且强制内联构建比非内联构建更慢。

我确实意识到性能高度依赖于主机参数；在一台机器上较慢的程序在另一台机器上可能会变得同样快甚至更快。但我正在寻找一种最坏的情况，即不受限制的内联显然会适得其反。

理想情况下，不影响内联的其他编译器后端选项（例如整体优化级别等）对于两个构建应该是相同的，以排除可观察到的差异由它们解释而不是由应用/跳过的内联解释的可能性。

我对此类程序的起点有一个想法，但我需要进一步的帮助来充实它：

1. 内部函数非常庞大，几乎无法放入 CPU 的指令缓存中。
2. 外部函数足够大，因此，如果将内部函数强制内联到其中，则生成的代码部分将大于 CPU 的指令缓存。
3. 程序的控制流以这样的方式组织：当所有内容都内联时，它会经历更高频率的指令缓存未命中、缓存刷新或类似事件，如果不强制内联，则不会发生这些事件。

我有ggplot如下两个对象。

library(ggplot2)

set.seed(1)
dat1 = data.frame(x = rnorm(1000), y = rnorm(1000))
dat2 = data.frame(x = rt(5000, 2))

Plot1 = ggplot(data = dat1, aes(x = x, y = y)) + geom_point()
Plot2 = ggplot(dat2) + geom_histogram(aes(x = x))

现在我想在 的左中部分Plot2叠加。所需的输出Plot1Plot1

为了获得更好的可见性，我还希望具有一定的透明度，Plot2以便Plot1在重叠区域不会完全被掩盖。

有什么方法可以实现吗？我在网上搜索了相关信息，但似乎都提到了添加图层。我的最终绘图结果与单纯添加图层的结果不同。

考虑到类型A定义如下：

typedef struct a { const int a; } A;

我知道此代码是有效的：

A * foo = malloc(sizeof *foo); // Allocates uninitialized memory with no effective type
memcpy(foo, &(typeof(*foo)){ .a = 42, }, sizeof *foo); // Effectively initialize the value once

（参见https://stackoverflow.com/a/79012045/13242312）

但是，如果我们希望值位于堆栈而不是堆中，alloca那么使用 而不是是否仍然有效？malloc

用例：我希望函数中有一个返回路径，因此我想在函数范围内定义结果变量

A A_new(void) {
  A * a = alloca(sizeof *a);

  if (/* something */) {
    memcpy(a, &(typeof(*a)){.a = 1}, sizeof *a);
  } else {
    memcpy(a, &(typeof(*a)){.a = 2}, sizeof *a);
  }

  return *a;
}

我不确定这里显示的登录 URL 有什么用处：

https://learn.microsoft.com/en-us/entra/identity/enterprise-apps/media/add-application-portal-setup-sso/saml-configuration.png

（来源：https ://learn.microsoft.com/en-us/entra/identity/enterprise-apps/add-application-portal-setup-sso ）

编辑：在上图中，登录 URL 标记为required，但在我的例子中它显示为optional。

据我了解，如果我设置了此 URL，它将把 SAML 响应重定向回此 URL 而不是 ACS，以便在 SP 端进一步登录。

因此，例如，如果我的应用程序在通过 IDP 身份验证后需要登录页面，它将重定向到登录页面。

但是为什么我不能只使用 ACS 重定向到登录页面？

尝试验证数据库查询的超时，但无法通过 HttpTestingController 实现。

不确定如何设计 UT。在这个设置中，应该在哪里添加超时。

    it('test timeout', () => {

        service.getData('2025-10-12', '2025-10-16').subscribe(
            {
                next: data => {
                    expect(data).not.toBeNull();
                },
                error: error => {
                    expect(error).toBeNull(); // handling all missing keys
                }
            }
        );

        // mocking endpoint - binding
        const response = httpController.expectOne({
            method: 'GET',
            url: RestServerSA.RELEASES_OVERVIEW_RANGE
        });

        // mocking response from endpoint
        response.flush({});
    });

我有一个使用 PHP openssl 使用密码 AES-CBC-256 加密的值，但最终值的密码也使用相同的方法加密。openssl_encrypt($key, $cipher, $passphrase, 0, $iv)

我需要能够使用 Python 解密这些数据，但遇到了块大小问题。

以下是我目前掌握的一些代码。我已经用 PHP 测试过解密，一切正常。本例中的最终值应该是“Jimmy”。

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

localKey = base64.b64decode('Po0KPxyF')
localIv = base64.b64decode('s8W+/a4jkp9mhO3NkCL7Yg==')

encrypted_value = base64.b64decode('hl5n6Nq5QYtgKIyLEVCupA==')
encrypted_key = base64.b64decode('MGRHRFlaMzhCR0lxb2VHS1JHQXcrWkV2bkJpNWFZb3cybW9iQW5KYTlOU0xKK1FHc2pPUW1MUE9JRU5zTXN1Rg==')
encrypted_iv = base64.b64decode('J31SrExr7KKIOertYIPhpQ==')

# First need to encrypted key that uses the local key as the passphrase
cipher_key = AES.new(pad(localKey,16), AES.MODE_CBC, localIv)
decrypted_key = cipher_key.decrypt(encrypted_key)

# Then decrypted the final value using the newly decrypted key
cipher_key = AES.new(unpad(decrypted_key,16), AES.MODE_CBC, encrypted_iv)
decrypted_value = cipher_key.decrypt(encrypted_value)

我有这个 Swift 结构：

struct Foo {
  let i: Int
}
let f1 = Foo(i: 1)
let f2 = Foo(i: 2)

然后在 LLDB 中，我将它们转换为__SwiftValue并打印出来：

p (f1 as AnyObject)

(__SwiftValue) 0x00000001676332d0 {
  baseNSObject@0 = {
    isa = __SwiftValue
  }
}

p (f2 as AnyObject)


(__SwiftValue) 0x0000000167633300 {
  baseNSObject@0 = {
    isa = __SwiftValue
  }
}

正如您所看到的，这两个地址是不同的，这是有道理的，因为它们无论如何都是位于不同内存位置的不同数据。

但是，如果我取ObjectIdentifier，它们就相等：

p ObjectIdentifier(f1 as AnyObject)
(ObjectIdentifier) ObjectIdentifier(0x00000001676332d0) {
  _value = 0x00000001676332d0
}

p ObjectIdentifier(f2 as AnyObject)

(ObjectIdentifier) ObjectIdentifier(0x00000001676332d0) {
  _value = 0x00000001676332d0
}

这种奇怪的行为基本上是说“相等的 ObjectIdentifier”并不意味着“相等的地址”（===）：

p (f1 as AnyObject === f2 as AnyObject)
(Bool)  (_value = 0)

p (ObjectIdentifier(f1 as AnyObject) == ObjectIdentifier(f2 as AnyObject))
(Bool)  (_value = 1)

为什么会这样？我的理解是__SwiftValue是 的子类NSObject，所以它们应该有不同的ObjectIdentifiers 。这很奇怪。

更新：

我在 LLDB 之外添加了示例代码：

      let f1 = Foo(i: 1)
      let f2 = Foo(i: 2)
      
      let b1 = (f1 as AnyObject) === (f2 as AnyObject)
      let b2 = ObjectIdentifier(f1 as AnyObject) == ObjectIdentifier(f2 as AnyObject)
      

并在调试器中得到 b1 = false 和 b2 = true：

我是一名 React Native 程序员，我在添加 Firestore 的两张截图时遇到了一个不合逻辑的问题，因为那里有一个集合，里面有一些文档。当我使用代码或查询生成器获取集合时，我得到了一个结果。仍然只有一个项目无法获取，请问问题出在哪里？我的 React Native 代码是

useEffect(() => {
    console.log('Starting useEffect');

    const fetchData = async () => {
      const querySnapshot = await firestore()
      .collection('chatRooms')
      .get();

    console.log('All docs count:', querySnapshot.size);

    console.log('All document IDs:');
    querySnapshot.forEach(doc => {
      console.log(`${doc.id}`);
    });

    // Filter client-side for rooms containing the user
    querySnapshot.forEach(doc => {
      const data = doc.data();
      console.log(`Doc ${doc.id} exists:`, doc.exists);
      console.log(`Doc ${doc.id} data:`, data);
      console.log(`Doc ${doc.id} data keys:`, Object.keys(data));
      console.log(`Doc ${doc.id} empty?:`, Object.keys(data).length === 0);

    });


    };
    fetchData();
  }, []);

如图所示，我有4份文件，但只获取到1份。如果有人知道这个问题，请告诉我。

HvN0az1wtzgNqnxkBm14z274LiO2_ai_1
HvN0az1wtzgNqnxkBm14z274LiO2_ai_10
HvN0az1wtzgNqnxkBm14z274LiO2_ai_12

我的文档 ID

我正在使用 MPI 库为大规模 CFD 代码设置 IO，并且随着问题规模的扩大，文件 IO 开始占用计算时间。

据我所知，现代背景下的“完成”的事情是大量利用集体 IO 操作，（ARCHER 上的并行 IO 性能- 2015 年白皮书）。

我的问题是，似乎有三种调用集体写入的方法：

• MPI_File_write_all，阻塞

• MPI_File_iwrite_all，非阻塞

并且有些推测：

• MPI_File_iwrite然后调用MPI_File_sync，先非阻塞然后阻塞？

  我之所以说是推测，是因为前一个调用显然是非集体的，而后者（据我所知，后者实际上是将数据推送到存储）是集体的。

我的问题是，多个MPI_File_iwrites 后跟 a是否MPI_File_sync等同于一个MPI_File_write_all，因为文件同步使得非集体写入有效地变成了集体写入？编辑 - 为了清楚起见，我知道 sync 是一个集体例程，我问的是调用 sync 时发生的 IO 是否类似于 write_all 的集体 IO。

后续问题：MPI_File_iwrite_all调用是否需要MPI_File_sync调用，如果确实需要，那么集体非阻塞写入的目的是什么，如果它只是变成了阻塞？

我在这里非常关注阻塞与非阻塞，因为我试图从我的代码中完全删除所有同步以提高 CPU 利用率（即，只有当进程缺少来自邻居的所需信息时才会等待，而不是等待所有进程同步）但显然这在输出时会出现一些问题。

如何用 Kotlin 编写此 Java 代码？

//Java
for (int i = 10; i > 0; i--);

如您所见，“i”不能为零。

我知道这个可以用“downTo”来完成，像这样：

for (i in 10 downTo 0)

但是“downTo”包含零。我希望它不包含零。我的问题是，在 Kotlin 中有没有办法做到这一点？（只在“for 循环”中实现，不改变零或十，也不用任何额外的“if”语句）