标签: profiling

今天，我对得到的 Visual VM 分析结果感到困惑。

我有以下简单的Java方法：

public class Encoder {
  ...
  private BitString encode(InputStream in, Map<Character, BitString> table) 
      throws IOException {

    BufferedReader reader = new BufferedReader(new InputStreamReader(in));

    BitString result = new BitString();
    int i;
    while ((i = reader.read()) != -1) {
      char ch = (char) i;
      BitString string = table.get(ch);
      result = result.append(string);
    }

    return result;
  }
}

此方法从流中一次读取一个字符。对于每个字符，它查找它的位串表示形式，并将这些位串连接起来以表示整个流。

BitString 是一种自定义数据结构，它使用底层字节数组表示位序列。

该方法的性能非常差。问题在于BitString#append- 该方法创建一个新的字节数组，从两个输入 BitString 复制位并将其作为新的 BitString 实例返回。

public BitString append(BitString other) {

  BitString result = new BitString(size + other.size); …

我正在检查 AngularJS 应用程序的性能问题。

执行特定操作时，CPU 使用率达到 100%，Chrome 窗口冻结，我必须使用 Chrome 的任务管理器手动终止进程。

我尝试调试该应用程序（DevTools 的Sources选项卡），但该应用程序非常大且代码被缩小，这意味着要找到问题并不容易：我看到许多由摘要循环触发的代码，并且无法弄清楚哪个代码是真正的罪魁祸首。

能够在应用程序冻结后对其进行分析可能会有帮助；我很确定分析器会立即显示实际的瓶颈。我可以在冻结发生之前成功启动分析器（性能选项卡），但是一旦应用程序冻结，当我单击停止按钮时，加载配置文件窗口就停留在 0%（我等了 15 分钟只是为了确定，它仍然在零），所以我想它也被冻结了。

因此我的问题是：

当我无法通过简单的调试应用程序找出问题时，如何找到导致应用程序冻结的原因？

我正在尝试学习使用 Go 的分析功能。考虑到这一点，我创建了这个简单的应用程序：https : //github.com/Matias-Barrios/countWords ，它只是计算给定txt文件的单词出现次数。

问题是，一旦创建了.cpu.prof文件，我就看不到任何东西。一旦我打开文件，我就会收到此错误：

(0) matias #> go tool pprof .cpu.prof 
File: main
Type: cpu
Time: Oct 9, 2019 at 12:38am (-03)
Duration: 201.31ms, Total samples = 0 
No samples were found with the default sample value type.
Try "sample_index" command to analyze different sample values.
Entering interactive mode (type "help" for commands, "o" for options)
(pprof) top
Showing nodes accounting for 0, 0% of 0 total
      flat  flat%   sum%        cum   cum% …

假设我有一个myapp不需要命令行参数的可执行文件，并启动 CUDA 内核mykernel。我可以调用：

nv-nsight-cu-cli -k mykernel myapp

并得到如下所示的输出：

==PROF== Connected to process 30446 (/path/to/myapp)
==PROF== Profiling "mykernel": 0%....50%....100% - 13 passes
==PROF== Disconnected from process 1234
[1234] myapp@127.0.0.1
  mykernel(), 2020-Oct-25 01:23:45, Context 1, Stream 7
    Section: GPU Speed Of Light
    --------------------------------------------------------------------
    Memory Frequency                      cycle/nsecond      1.62
    SOL FB                                %                  1.58
    Elapsed Cycles                        cycle              4,421,067
    SM Frequency                          cycle/nsecond      1.43
    Memory [%]                            %                  61.76
    Duration                              msecond            3.07
    SOL L2                                %                  0.79
    SM Active Cycles                      cycle              4,390,420.69
    (etc. etc.)
    -------------------------------------------------------------------- …

我需要一些帮助来理解一些 GHC 堆配置文件。我正在为语法框架语言的现有编译器开发一种新的输出格式。

前

分析当前版本编译器的正常运行如下所示：

  13,347,660,488 bytes allocated in the heap
 213,062,924,208 bytes copied during GC
     740,585,528 bytes maximum residency (567 sample(s))
       4,844,112 bytes maximum slop
            1438 MiB total memory in use (0 MB lost due to fragmentation)

                                     Tot time (elapsed)  Avg pause  Max pause
  Gen  0     12312 colls,     0 par    1.321s   1.382s     0.0001s    0.0025s
  Gen  1       567 colls,     0 par   206.442s  208.534s     0.3678s    0.8388s

  INIT    time    0.001s  (  0.005s elapsed)
  MUT     time   68.757s  ( 68.986s elapsed)
  GC …

我很好奇使用C和python进行insert-sort的性能,但是我得到的结果让我想到如果我做错了什么.我怀疑C会更快,但不是那么多.

我已经分析了两个代码,插入排序功能是花费时间最多的地方.

这是C函数:

void
insert_sort (vec_t * vec)
{
    int j;
    for (j = 1 ; j < vec->n ; j++){
        int key = vec->v[j];
        int i = j - 1;
        while (i >= 0 && vec->v[i] > key){
            vec->v[i+1] = vec->v[i];
            i--;
        }
        vec->v[i+1] = key;
    }
}

这是python函数:

def insert_sort (ln):
    for j in range(1, len(ln)):
        key = ln[j]
        i = j-1
        while i >= 0 and ln[i] > key:
            ln[i+1] = ln[i]
            i-=1
        ln[i+1] = key

用10000个整数进行测试,每个整数随机生成0到10000之间. …

我正在分析我的一些计算密集型代码，并且很惊讶地看到该函数RtlpNtMakeTemporaryKey占用了大量时间。它的模块是ntdll，源文件是Unknown。这是一个等待我慢速功能终止的调用，还是可以优化的调用？

什么是从STDIN读取多个1000000个字符(整数)的最快方法,并将其拆分为一个字符整数(不是字符串)的数组？

123456 > [1,2,3,4,5,6]

正如标题所暗示的那样:假设我们有一个复杂的程序,我们想让它更快,但我们可以.我们能否以某种方式检测哪些循环或其结构的其他部分占用大部分时间来进行优化？

编辑:注意,重要的是假设软件非常复杂,我们不能逐个检查每个循环或其他结构,将定时器放在其中等.

我正在为我的分析代码编写单元测试.为了做到这一点,我正在编写一些函数来分配内存并调用'sleep'以生成可以测试的可预测内存和时间结果.

"分配内存"部分结果有点棘手.

没有'malloc'类型函数,我尝试追加一个字符串:$ myString.='x'; 并附加到数组:$ myArray [] = null;

但我的结果表明,这些结构不会按需线性分配内存.

您的建议表示赞赏!