我正在寻找答案，但没有找到明确的答案。我该如何解释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无论如何，简单地调用都可能导致依赖纹理读取。是这样吗？如果是这样，如何在访问目标像素周围像素的精确值时避免依赖纹理读取？
我如何设计一个在高峰时间处理 100k req/s 的系统，每个请求执行 20kb 大小内的对象更新？
我使用nodejs作为非阻塞io的后端，使用redis作为缓存和mongodb作为数据库的后写模式，但它在峰值时仅处理10k req/s。
我有一个自定义 PyTorch 模型，由于当前的使用方式，该模型成为我的应用程序的瓶颈。
该应用程序是一个在 Flask 中构建的 Web 服务器，用于接收 PyTorch 模型处理的作业提交。由于每个作业的处理时间，我使用 Celery 来处理计算，其中 Flask 将任务排队以供 Celery 执行。
每个作业都包括从磁盘加载 PyTorch 模型、将模型和数据移动到 GPU 以及对提交的数据进行预测。然而，加载模型大约需要 6 秒。在许多情况下，这比预测时间大一两个数量级。
因此，是否可以在服务器启动时（特别是 Celery 工作线程启动时）加载模型并将其移动到 GPU，从而避免每次作业加载模型并将其复制到 GPU 所需的时间？理想情况下，我希望在服务器启动时加载模型并将其复制到每个可用的 GPU，让每个 Celery 作业选择一个可用的 GPU 并复制数据。目前，我只有一个 GPU，因此目前不需要多 GPU 解决方案，但我正在提前计划。
此外，模型和数据的内存限制只允许每个 GPU 一次执行一项作业，因此我有一个 Celery 工作线程来顺序处理作业。由于避免多个作业同时尝试在共享内存中使用模型，这可以降低解决方案的复杂性，所以我想我应该提到它。
截至目前，我正在使用 PyTorch 的多处理包和forkserverstart 方法，但我很难确定它到底是如何工作的以及它是否按照我喜欢的方式运行。如果您对我的配置有任何意见或对解决方案有任何建议，请发表评论！我愿意接受效率建议，因为我打算扩展这个解决方案。谢谢你！
如果您去年一直活跃在编程社区中，那么您肯定听到过对 Rust 执行速度和性能以及ResultRust 中出色类型的赞扬。
我可能应该提一下，我不是 Rust 开发人员。尽管如此，或者甚至可能正因为如此，我想知道如果 Rust 使用这个 Result 类型，它怎么会如此高效，因为就我而言，这个类型被实现为所谓的union在C . 它在联合中包含一个错误和一个返回值，其中在给定时间只有一个有效。该类型还包含一个标志，指示结果是否包含错误或值。
如果我计数正确，并且假设错误存储为指针或引用（例如，在 64 位系统上占用内存中的 8 个字节），则联合最少 8 个字节 + 标志一个字节，使得9字节内存。
现在，通过填充，我假设在大多数系统上，这将被重新对齐以占用 12 个字节。相比之下，返回 int(32) 仅分配 4 个字节。因此，使用 Result 分配的内存应该是使用 int 的三倍。
这不是极大地浪费内存吗？我想象在循环中运行它，这会增加很多。
我不太明白为什么有人会声称 Rust 性能超级好，而 Result 却占用了那么多内存？
我知道有一些优化技巧可以减少内存使用量，例如使用带有选项的 NotZeroInt 使编译器可以使用零作为标志，从而避免为标志提供额外的字节。但对于大多数类型来说这并不适用，不是吗？
如果有人有进一步的见解，我很想听听。请注意，我不是 Rust 开发人员，出于好奇而提出这个问题，正如我在尝试移植此功能的库中观察到的那样，内存使用量急剧增加。
当然，RustResult<T, E>和Option<T>类型比某些移植库进行了更好的优化，但我无法想象这如何不会影响程序性能。
我一直在尝试探索Haskell中递归的可能性，但在面对大递归时如何提高效率我不太了解。今天，我想做一个计算第二类斯特林数的函数：
factorial :: Integer -> Integer
factorial n = helper n 1
where
helper 1 a = a
helper n a = helper (n-1) (a*n)
stirling :: Integer -> Integer -> Integer
stirling n 1 = 1
stirling n 2 = ((2 ^n)- 2) `div` 2
stirling n k
| k > n = 0
| k == n = 1
| k == (n-1) = (factorial n) `div` (factorial 2 * (factorial(n-2)))
| otherwise = stirling (n-1) (k-1) + k *(stirling (n-1) k)
我一直在尝试创建一个辅助函数，就像阶乘定义中一样，可以避免 Haskell 的惰性求值占用过多内存资源带来的不便。我想做同样的事情，在每次调用中计算乘积
k *(stirling (n-1) k)
递归，但我没有掌握它的窍门。有任何想法吗？
PD：代码已经运行得相当不错，但我是 Haskell 的新手，我仍然不知道可能性是什么。欢迎任何改进（尽管我认为不使用任何库；我想在进入之前学习基础知识）。