标签: performance-testing

我想更改代码中特定方法的实现方式。在将该更改提交到生产之前，我想确保我的更改对该特定方法的性能没有影响或影响很小。是否有任何工具可以让我轻松地测试 .NET 中各个方法实现的性能？我还能如何实现这种精细的性能测试？

这是第一次，我的团队要求我对数据库进行一些测试，但我不知道如何进行。通过对数据库进行测试，我的意思是，我需要看看它插入记录的速度有多快。以及它能承受多大的压力。就像数据库的负载和性能测试一样。我们将要使用的数据库是XPRESSmp。

那么，任何人都可以帮助我，当我们需要测试数据库时，我们通常会进行什么样的测试，以及我可以为此研究哪些工具。我看过的大多数文章大多与 Oracle 和 MySQL 相关。但这完全是一个新的数据库。

我能想到的一种方法是编写一个具有 X 个线程的多线程程序，它将以非常高的速度将数据泵入 XMP。并继续测量每个线程花费的时间。我还能做什么来测试数据库？

我的团队要求我通过测试来破坏数据库，但我们应该知道它是在什么情况下破坏的以及背后的原因是什么。

以及在对数据库进行测试时我应该了解和考虑哪些要点。

PS 我将在单独的 LnP 机器上进行此测试。

我想测试 android 的 html5/Javascript Web 应用程序，因此我购买了 Nexus 7（第二代），并将操作系统升级到最新的 4.3。

Nexus 的规格比我之前测试的 iPad 2 好很多：

• 2GB 内存 vs 512MB
• 1.5GHz x 4 核与 1GHz x 2 核

不过，我发现网页上的 Nexus UI 交互速度比 iPad 慢约 5-10 倍。按钮按下、动画等都非常滞后。例如，在 iPad 2 上，从按下到未按下的按钮按下翻转的速度与手指抽动的速度一样快，即使在敲击两根手指时也是如此（大于 5 次/秒）。而 Nexus 明显落后于用户触摸速度，不到 1/秒。事实上，Android/Nexus 速度太慢，有时会错过非触摸事件，使按钮处于按下状态。

我想弄清楚这一点，这是操作系统的限制吗？硬件有问题吗？（虽然这是谷歌自己的设备）Java JVM 开销是否限制了性能？（尽管我认为 Chrome 都是原生的 C/C++）。有解决办法吗？

我运行了浏览器 JavaScript 测试 (Dromaeo)，计算结果正如您所期望的那样（较新的快速 Nexus 大约是旧 iPad 速度的 2 倍）。尽管我确实注意到，奇怪的是，iPad 在 DOM 操作测试中的表现优于 Nexus 大约 2 倍，但仍然不如用户体验那么引人注目。

有什么想法吗？

据我所知，一般可以用三种方式来描述程序运行时间的限制：CPU 限制、内存限制和 I/O 限制。如何证明程序是内存受限的？

我们正在对我们的一个遗留应用程序进行性能测试，当时我们发现没有类加载持续增加，从而导致非堆内存的增加。

现在我正在寻找根本原因，我能想到的一件事是，在几个地方我们使用 Class.forName ，如下所示：

Test a = (Test) Class.forName(className, false, Test.class.getClassLoader()).newInstance();

这能是一个理由吗？如果上述代码语句中的类名相同，则调用 class.forName 是否会一次又一次加载相同的类。

应用服务器：Jboss 6.1 EAP

JDK：1.6.27

jmeter文档说

http://jmeter.apache.org/usermanual/component_reference.html#assertions

运行采样器的所有断言后，变量 JMeterThread.last_sample_ok 更新为“true”或“false”。

我的测试计划中有一个 http 采样器，它通过几个重定向执行登录。

有趣的是，我发现即使在我的断言失败后， JMeterThread.last_sample_ok 也被设置为 true 。我正在使用响应断言在登录后断言字符串。即使断言失败，该变量也会设置为 true。这会导致下一个“if 控制器”也继续执行错误的响应。我是不是错过了什么？

在此先感谢您的帮助。

我们的测试计划中有7个线程组：

Thread group 1
Thread group 2
Thread group 3
Thread group 4
Thread group 5
Thread group 6
Thread group 7

当线程组 1 完成时，我需要在线程组 2 启动之前添加延迟。我考虑过在每个线程组中添加启动延迟（秒），或者添加一个包含 Thread.sleep(60); 的 beanshell 例如。哪种方法是最好的？

我不清楚如何在 Gatling 中控制封闭的工作负载模型。

如果我使用constantConcurrentUsers，像这样：

myScenario.inject(
    constantConcurrentUsers(40) during (2 minutes)
)

我认为这意味着活跃用户的数量将保持不变。但相反，我得到这样的报告：

用户数量不是恒定的，是我想要的数量的 3-5 倍。

不过，在控制台输出中，我可以看到某些内容是恒定的（这里有 4 个场景，每个场景都加载了 10 个恒定并发用户）：

但是总负载比我预期的要多得多。

我曾尝试过节流，结果很明显。在我的理解中，节流阀使并发活动请求的数量最大化（如果请求已发送但尚未响应，则该请求处于活动状态）。我定义了一些应该通过的请求，每次完成时 Gatling 都会发送一个新请求。并且由于响应时间之间没有太大差异，因此报告如下所示：

我想做同样的事情，但这样我就可以控制模拟的长度，而不是发送的请求总数。constantConcurrentUsers似乎正是我需要的东西，但它产生了意想不到的结果。我的油门模拟在大约1分钟内做了大约3000个请求，油门为50。同时，如果我设置50个并发用户1分钟，报告中发送了7000多个请求。在油门情况下，响应时间要短得多。所以节流模拟发送请求比并发用户模拟慢得多，但不是因为请求需要更多时间。

我知道活动用户和发送的请求是不一样的，它们constantConcurrentUsers控制用户数量，而节流控制请求。但是我所有的场景都只包含一个请求，所以我不明白结果之间的区别。

所以我的问题是：

• 当我使用时到底什么是常数constantConcurrentUsers？
• 我使用时如何计算请求数constantConcurrentUsers？
• 报告中的“活跃用户”与控制台输出中的“活跃用户”之间有什么关系？

我已经阅读了 Gatling 文档的这一部分，它真的很短，而且缺乏详细的描述。我还阅读了这篇文章，其中包含我从未在任何 Gatling 报告中看到的图表，并且没有回答我的问题。

感谢您的任何贡献。

问题

Julia 是否有一种有效的方法从给定的条目列表 (u,v,w)构建一个巨大的稀疏矩阵，其中一些可以具有相同的位置(u,v)，在这种情况下，它们的权重 w 必须是总和。因此u,v,w是输入向量，我希望创建一个w[i]在 position 处具有值的稀疏矩阵u[i],v[i]。例如，Mathematica 代码

n=10^6;   m=500*n;   
u=RandomInteger[{1,n},m];   
v=RandomInteger[{1,n},m];   
w=RandomInteger[{-9, 9}, m];   AbsoluteTiming[
SetSystemOptions["SparseArrayOptions"->{"TreatRepeatedEntries"->1}]; 
a= SparseArray[{u,v}\[Transpose] -> w, {n,n}]; ]

需要 135 秒和 60GB 的 RAM。等效的 Python 代码

import scipy.sparse as sp   
import numpy as np
import time
def ti(): return time.perf_counter() 
n=10**6; m=500*n;
u=np.random.randint(0,n,size=m);            
v=np.random.randint(0,n,size=m);            
w=np.random.randint(-9,10,size=m); t0=ti(); 
a=sp.csr_matrix((w,(u,v)),shape=(n,n),dtype=int); t1=ti(); print(t1-t0)

需要 36 秒和 20GB，但不支持 (2)。等效的 Julia 代码

using SparseArrays;
m=n=10^6; r=500*n; …

我正在试验一种用于任意精度算术的算法，并希望使用std::array. 并且由于我std::vector用作长整数的动态存储，因此我决定使用std::variant<std::array, std::vector>此短整数优化。我不确定 std::visit 的性能，所以我使用 Google 基准测试了它。事实证明，它std::visit比正常直接访问容器内的元素要快。

std::visit在 MSVC 上作为 switch case 实现，除了std::variant由于标记联合而具有更大的内存占用之外，怎么可能std::variant更快？有人对此有解释吗？

测试代码：

#include <array>
#include <variant>
#include "benchmark/benchmark.h"

static void VecOf_VariantOf_Vec_Arr(benchmark::State& state) {
    using ST = std::array<uint8_t, 20>;
    std::vector<std::variant<std::vector<uint8_t>, ST>> vec;

    vec.reserve(1024 * 1024);
    for (auto i = 0u; i < 1024 * 1024; ++i)
        vec.emplace_back(std::in_place_type<ST>);

    for (auto idx = 0u; auto _ : state) {

        std::visit([idx]<typename T0>(T0& e)
        {
            if constexpr (std::same_as<T0, ST>)
                e.fill(static_cast<uint8_t>(idx)); …