问题[performance](coding)

假设我有一个定义在 0<= x<= pi, 0<=y, z<=2pi 上的函数。我编写了一个 matlab 代码来全局搜索最大点，步长为 0.01。我还恢复了函数值。代码是（当然函数比 x+y+z 更复杂。这只是一个例子。）

x=0;
y=0;
z=0;
i=1;

Maxdeviation= ComputeDeviationSum(0,0,0,mufT, mufD, mufC);
MaximizingArg= [x, y,z] ;
while x<= pi
    y=0;
    z=0;
    while y<= 2*pi
        z=0;
        while z<=2 *pi
            deviation= x+y+z; % Just an example. The function is more complex.
            if deviation> Maxdeviation
                MaximizingArg= [x, y,z];
                Maxdeviation= deviation;
            end
            a(i,:)=[x, y,z, deviation];
            z=z+0.01;
            i=i+1;
        end
        y=y+0.01;
    end
    x=x+ 0.01;
end

我发现这真的很慢。在我删除了三行恢复值之后，即删除

i=1;
a(i,:)=[x, y,z, deviation];
i=i+1

这三行代码，速度就快了很多。（我在 20 秒后停止了执行，发现后者比前者多执行了 10 倍的迭代次数。）

我的问题是：为什么停止恢复值后，代码会快得多？如果我想为每个点恢复值，我该怎么做才能让代码更快？

我做了一些看起来很聪明的事情。为了更好地处理错误，我编写了如下 DB 操作

    fn handle_delete(&self, id: &Id) -> Result<(), SqliteError> {
        db_op(
            || DbOperationInfo::new("filerequests", OperationType::Delete),
            || {
                self.conn
                    .execute("DELETE FROM filerequests WHERE id = ?", [id.to_string()])?;
                Ok(())
            },
        )
    }

我的想法是，我有我的 SqliteError 枚举，它包含一个相当小的结构，其中包含有关尝试的操作及其rusqlite::error::Error原因的一些信息。

该db_op函数的作用是接受两个闭包，第一个闭包生成包含操作信息的小结构，第二个闭包执行实际操作。如果（且仅当）发生错误，则执行第一个闭包生成操作信息，然后添加导致错误的代码以创建SqliteError。

因此操作信息的创建是懒惰的。

但是我在这里真的有收获吗？还是创建闭包的成本同样高昂？或者，也许编译器会优化闭包创建并只执行一次？或者也许它会同样优化结构创建（内容有点静态）？

在此寻求一些指导：这种优化（可能）真的有帮助吗？

我在 Groovy 中对两个哈希图进行比较，如下例所示

 h1 = [key1 : [att1 : 1, att2 : 2], key2 : [att1 : 10, att2 : 20], key3 : [att1 : 3, att2 : 4]]
 h2 = [key1 : [att1 : 1, att2 : 3], key2 : [att1 : 10, att2 : 20]]

我需要如下结果

 [key1:[att1:true, att2:false], key2:[att1:true, att2:true], key3:[att1:false, att2:false]]
 

即，如果给定键的属性匹配，则应将其标记为true，如果它们不匹配或第二个源中缺少该键，则应将其设置为false

我尝试了这个嵌套的闭包，

 diff = h1.collectEntries {key, value -> [key,  (value.collectEntries {k, v -> [k, (v == (h2[key] ? h2[key][k] : null) ) ] } ) ] }

它可以工作，但是对于大地图比例来说效果不佳，Groovy 中是否有更好的解决方案？

请注意，如果这可能相关，则属性在所有情况下都是相同的并且是提前知道的。

我正在开发一个网站https://www.paveinsight.com。该网站使用 Next.js 编写并托管在 Vercel 上，主页生成为静态页面。

运行 PageSpeed Insights 时，我的 LCP 很慢，在移动设备上尤其慢，我不知道原因。图片经过优化，根据屏幕调整大小并托管在 Amazon CloudFront 上。在我的实际设备上测试，页面加载速度很快，而且很流畅。在我的 Pixel 7 上加载的 webp 图片为 81KB，但 PageSpeed Insights 表示 LCP 在移动设备上为 9.4 秒。

模拟的 4G 连接速度为 1,638 kb/s，因此我预计下载时间将远少于 1 秒。下面是所用时间的明细。什么可能导致 TTFB 过高，或极端的加载延迟和渲染延迟？

TTFB 6% 600ms
Load delay 53% 4,920ms
Load time 1% 80ms
Render delay 40% 3,750ms

我正在寻找答案，但没有找到明确的答案。我该如何解释perf report输出中的第一行。它是这样的：

Samples: 173M of event 'cache-misses', Event count (approx.): 461731712088

我看过的几乎每个教程都讲到了所有内容，除了第一行。本页解释了样本和计数之间的区别，但我想 100% 确保我没有得出错误的结论：在我的例子中，173M和461731712088是什么意思？从我读到的内容来看，我猜第二个是运行时发生的缓存未命中总数，第一个是记录并用于显示统计信息的缓存未命中数。这是正确的还是我误解了输出？

就我使用 MAUI 的经验而言，我只使用<VerticalStackLayout/>和<HorizontalStackLayout/>来水平或垂直定位子元素。

我很少或几乎从来不用，<StackLayout/>因为我读到过它的性能可能会稍差一些。

什么时候建议使用<StackLayout/>和调整其Orientation属性？

我应该使用...

<StackLayout Orientation="Horizontal">
<StackLayout/>

<StackLayout Orientation="Vertical">
<StackLayout/>

...而不是...

<HorizontalStackLayout>
<HorizontalStackLayout/>

<VerticalStackLayout>
<VerticalStackLayout/>

...或者反过来，取决于不同的情况？

对于简单的数学运算，例如sqrt(2)，，，，，1 / 2等等， CPU 是否包含某种硬件表，其中包含这些运算的结果，因此它们实际上不是“1 + 1计算”的，而是从某种字典或“数学缓存”中获取的，以便更快地处理？当然，我预计有些人会问“谁来定义什么是‘简单’数学运算？”，但我只是很好奇。10^21 * 0tan(45)

我在 Arduino 上编写了我的类的成员函数Adf，bool Adf::sendAndReceive(char *data, uint8_t length)该函数通过指向的串行端口发送一个字符数组Adf::pSerial，然后读取 rx 缓冲区。rx 和 tx 线路已连接，因此每个发送的字节都会回显到 rx 缓冲区中。此外，我使用ArduinoLog库来跟踪整个流量。现在我遇到了一个非常奇怪的情况：我sendAndReceive使用相同的参数连续两次调用，在第一次调用期间，记录传出消息花费不到 1 毫秒，但在第二次调用中花费了 29 毫秒。

为什么使用相同的参数调用相同的函数会花费不同的时间？

这些是被调用的函数：

bool Adf::sendAndReceive(char *data, uint8_t length)
{
  uint8_t rxTxLength = 0;

  // send data
  unsigned long start = millis();
  rxTxLength = pSerial->write(data, length);
  unsigned long end = millis();
  Logger.trace("TX start: %lu, end: %lu, duration: %lu\n", start, end, end - start);

  // STRANGE BEHAVIOUR HAPPENS HERE ===================
  unsigned long start2 = millis();
  // Trace the sent bytes
  Logger.trace("%s - data: ", __func__);
  traceCharArray(data, rxTxLength);
  unsigned long end2 = millis();
  Logger.trace("Trace start: %lu, end: %lu, duration: %lu\n", start2, end2, end2 - start2);
  // ==================================================

  // handle write error
  unsigned long start3 = millis();
  if (rxTxLength != length)
  {
    Logger.errorln("%s - Error writing to serial. Only %d of %d bytes written.",
                    __func__,
                    rxTxLength,
                    length);
    return false; // Failure: error writing to serial
  }
  unsigned long end3 = millis();
  Logger.trace("Error start: %lu, end: %lu, duration: %lu\n", start3, end3, end3 - start3);

  // Read all echoed bytes
  unsigned long start4 = millis();
  char echo[length];
  getAdfResponse(echo, length);
  unsigned long end4 = millis();
  Logger.trace("Echo start: %lu, end: %lu, duration: %lu\n", start4, end4, end4 - start4);

  // Compare sent and echoed bytes
  unsigned long start5 = millis();
  if (memcmp(data, echo, length) != 0)
  {
    Logger.errorln("%s - Serial was not echoed correctly", __func__);
    return false; // Failure: echoed bytes do not match sent bytes  
  }
  unsigned long end5 = millis();
  Logger.trace("Compare start: %lu, end: %lu, duration: %lu\n", start5, end5, end5 - start5);
  return true; // Success: all bytes echoed correctly
}

void Adf::traceCharArray(char *data, uint8_t length)
{
  for (int i = 0; i < length; i++)
  {
    Logger.trace("%x, ", static_cast<unsigned char>(data[i])); 
    /* static cast to ensure that the data is correctly interpreted as an 
    ** unsigned value when logging in hexadecimal format */
  }
  Logger.traceln("");
}

Adf::traceCharArray问题发生在调用该函数的“Trace”部分。

这是主文件

#include <Arduino.h>
#include <ADF.h>

#define ADDRESS_WIRE 33
#define BAUD_RATE    2400

Adf adf(ADDRESS_WIRE, &Wire1, BAUD_RATE, &Serial3);
char msg = 0x81;

void setup()
{
  // initialize Serial
  Serial.begin(9600);
  Serial.println("Hello ADF");

  adf.Logger.begin(LOG_LEVEL_TRACE, &Serial, false);

  // initialize ADF
  if (!adf.begin())
  {
    Serial.println("Init failed.");
  }

  if (!adf.sendAndReceive(&msg, 1))
  {
    Serial.println("sendAndReceive failed.");
  }
  Serial.println("====================================");
  if (!adf.sendAndReceive(&msg, 1))
  {
    Serial.println("sendAndReceive failed.");
  }


  // signal setup OK
  Serial.println("Setup done.");
}

void loop()
{

}

这是 Logger 打印的输出（以及我的注释​​）：

---- Opened the serial port COM3 ----
13:29:10:875 -> Hello ADF
13:29:16:384 -> TX start: 5513u, end: 5513u, duration: 0u
13:29:16:429 -> sendAndReceive - data: 81, 
13:29:16:458 -> Trace start: 5513u, end: 5513u, duration: 0u <--- compare this
13:29:16:503 -> Error start: 5513u, end: 5513u, duration: 0u
13:29:16:552 -> getAdfResponse - resp: 81, 
13:29:16:581 -> Echo start: 5545u, end: 5574u, duration: 29u
13:29:16:626 -> Compare start: 5621u, end: 5621u, duration: 0u
13:29:16:677 -> ====================================
13:29:16:716 -> TX start: 5709u, end: 5709u, duration: 0u
13:29:16:761 -> sendAndReceive - data: 81, 
13:29:16:790 -> Trace start: 5753u, end: 5782u, duration: 29u <--- to this
13:29:16:835 -> Error start: 5830u, end: 5830u, duration: 0u
13:29:16:884 -> getAdfResponse - resp: 81, 
13:29:16:913 -> Echo start: 5877u, end: 5906u, duration: 29u
13:29:16:958 -> Compare start: 5953u, end: 5953u, duration: 0u
13:29:17:007 -> Setup done.

问题Adf::traceCharArray：为什么即使传递了相同的参数，第一次调用也需要0ms，而第二次调用却需要 29ms？

注意：经过进一步研究，我发现如果Adf::traceCharArray直接调用（而不是从另一个函数中调用），则不会发生此问题：

在主文件中

  unsigned long start = millis();
  adf.traceCharArray(&msg, 1);
  unsigned long end = millis();
  Serial.print("duration: ");
  Serial.println(end - start);
  Serial.println("====================================");
  unsigned long start2 = millis();
  adf.traceCharArray(&msg, 1);
  unsigned long end2 = millis();
  Serial.print("duration: ");
  Serial.println(end2 - start2);

输出

---- Opened the serial port COM3 ----
13:46:12:418 -> Hello ADF
13:46:17:927 -> 81, 
13:46:17:935 -> duration: 0
13:46:17:958 -> ====================================
13:46:17:988 -> 81, 
13:46:17:992 -> duration: 0
13:46:18:004 -> Setup done.

编辑：我发现问题仍然存在，即使traceCharArray(data, rxTxLength);注释掉了对的调用。因此，该行的执行时间Logger.trace("%s - data: ", __func__);在 0 到 29ms 之间变化。

假设我有两个矩阵：

A = [1;
     2;
     3;
     4;
     5]

和

B = [1 1 2 1;
     2 3 3 4;
     5 5 5 5;
     1 4 4 4;
     5 5 1 2]

我需要一个结果矩阵来显示 A 中的项目在 B 中的相应行中出现了多少次，如下所示：

C = [3;
     1;
     0;
     3;
     2]

目前，我正在使用 for 循环内的 ismember 来执行此操作，并将每行的结果相加。但由于矩阵的大小，这需要很长时间。有没有不使用循环就可以做到这一点？

编辑以显示我当前的代码：

for i=1:1:length(A)
    C(i) = sum(ismember(B(i,:),A(i)),2);
end

但实际上，我的矩阵有超过 500k 行，我希望通过删除循环来提高该代码的效率。

我正在编写一个片段着色器，它必须在给定像素周围的区域中对给定纹理进行采样。我使用texelFetch而不是，texture因为我想要相邻像素的精确值而不进行任何过滤。最初我编写的代码如下：

in vec2 pixel;
uniform sampler2D tex;

void main() {
    float leftPixel = texelFetch(tex, ivec2(pixel.x - 1, pixel.y), 0).r;
    ...
}

然而，在阅读了有关依赖纹理读取的内容后，我将代码更改为更像这样：

in vec2 pixel;
in vec2 leftPixelLoc;
uniform sampler2D tex;

void main() {
    float leftPixel = texelFetch(tex, ivec2(leftPixelLoc), 0).r;
    ...
}

在上面的代码中，顶点着色器leftPixelLoc为我计算。我希望这可以防止依赖纹理读取。但是，我现在意识到，ivec2无论如何，简单地调用都可能导致依赖纹理读取。是这样吗？如果是这样，如何在访问目标像素周围像素的精确值时避免依赖纹理读取？