标签: execution-time

我正在尝试测量几种方法的执行时间.所以我想多做一个方法而不是重复相同的代码.

这是我的代码:

private void MeasureExecutionTime(Method m)
{
    startTime = System.nanoTime();
    try
    {
        m();
    }
    finally
    {
        endTime = System.nanoTime();
    }
    elapsedTime = endTime - startTime;
    System.out.println("This takes " + elapsedTime + " ns.");
}

假设我有myMethod(),我怎么MeasureExecutionTime()用来衡量myMethod执行时间？

while循环

测试条件,如果是,则执行代码

do..while循环

第一次执行.然后测试并执行.

所以之间的差异while,并do..while进行,程序在同时,一个试验进行比同时做多

那是

如果一个循环从1到50在while一个语句的循环中执行,它将有51个测试(50个真和1个假),语句将执行50次.

同样

如果一个循环从1到50在do..while循环中执行一个语句,它将有50个测试(第一个测试将不会执行),语句将执行50次.

所以,只有一个测试/检查少.而已.

但是当我测试执行所花费的时间时,它显示出很大的差异.

function whileFn() {
  var i = 0;
  while (i < 10) {
    document.write(i);
    i++;
  }
}

function doWhileFn() {
  var i = 0;
  do {
    document.write(i);
    i++;
  } while (i < 10)
}

console.time('whileFn');
whileFn();
console.timeEnd('whileFn');

document.write('<br/>');

console.time('doWhileFn');
doWhileFn();
console.timeEnd('doWhileFn');

正如您在图像和代码示例中看到的那样,while循环花费do while了15毫秒,而只花了5毫秒.

这种巨大差异背后的原因是什么？

测试10个元素

按照@pid的建议更新

测试1000

需要23mS进行1次额外测试

测试10000

一次额外测试多397.91 mS

进行测试

Chrome(58.0.3029.110) …

例如,FastCGI服务器对PHP脚本施加了执行时间限制,这些限制在PHP中无法使用set_time_limit().IIS我也相信这样做.

我为一个PHP应用程序编写了一个导入脚本,该应用程序在mod_php下运行良好,但在FastCGI(mod_fcgid)下失败,因为脚本在一定的秒数后被杀死.我还不知道在这种情况下检测你的时间限制的方法,还没有决定我将如何绕过它.使用重定向以小块方式执行它看起来像一个kludge,但如何？

在编写长时间运行的任务(例如导入或导出任务)时,您将使用哪些技术,其中单个PHP脚本可能在一定秒数后被服务器终止？

请假设您正在创建一个可移植脚本,因此您不一定知道PHP最终是在mod_php,FastCGI还是IIS下运行,还是在服务器级别强制执行最长执行时间.这可能也排除了shell脚本等.

我不知道这是否是一个有效的比较或有效的声明,但在我听人声称C语言编写的程序岁月++通常需要较长的时间进行编译比C语言编写的相同,并且在C++编码的应用在运行时通常比用C语言写的更慢
.这些陈述中是否有任何事实？
除了从C++提供的OOP灵活性中获益之外,是否应该从编译/执行时间的角度对上述比较进行考虑？

我希望这不会因为过于笼统或模糊而被关闭,它只是试图了解我多年来从许多程序员(主要是C程序员)听到的语句的实际事实.

我正在使用python,并假设我有一些代码如下

example.py

import os, psutil
import MySQLdb as mdb

conn = mdb.connect(user='root', passwd='redhat', db='File_Data', host='localhost', charset="utf8")
file_path = "/home/local/user/Module/File_processing/part-file.txt"
p = psutil.Process(os.getpid())
cursor = conn.cursor()

for line in file_open:
    result = line.split('\t')
    query = "insert into PerformaceReport (campaignID, keywordID, keyword, avgPosition)"
    query += " VALUES (%s,%s,'%s',%s)%(result[0],result[1],result[2],result[3])"
    cursor.execute( query )
conn.commit()

print p.get_cpu_times()
print p.get_memory_percent()

上面的代码从文本文件中读取数据并保存到数据库并且工作正常

我正在使用该命令运行该文件 python path/to/the/example.py

现在我要做的是找到/捕获以下三个值/信息

1. execution timepython脚本(example.py)用于读取数据并将数据保存到数据库的总量
2. CPU utilization当python脚本(example.py)运行(执行)时
3. Memory usage当python脚本(example.py)运行(执行)时

我已经用Google搜索了很多,发现了一些信息, 在这里,这里和这里 …

确保两个选项之间执行的时间更短的成本:

A:

if(something!=null){
    ...
}else{
    //log
}

要么:

B:

try{
    something.getField();...
}catch(Exception e){
    //log
} 

在这里,我使用-O2优化级别(使用gcc 4.8.4)编译输入程序并测量执行时间:

gcc -O2 -c test.c -o obj.o
TIMEFORMAT='%3R' &&  time(./obj.o)
execution time = 1.825

当我将-O2标志替换为在-O2 https://gcc.gnu.org/onlinedocs/gcc-4.8.4/gcc/Optimize-Options级别中GCC manuel中定义的选项列表. html#Optimize-Options就像这样:

gcc -fauto-inc-dec -fcompare-elim -fcprop-registers -fdce -fdefer-pop -fdse -fguess-branch-probability -fif-conversion2 -fif-conversion -fipa-pure-const -fipa-profile -fipa-reference -fmerge-constants -fsplit-wide-types -ftree-bit-ccp  -ftree-builtin-call-dce -ftree-ccp -ftree-ch -ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -ftree-phiprop -ftree-slsr -ftree-sra -ftree-pta -ftree-ter -funit-at-a-time -fthread-jumps -falign-functions  -falign-jumps -falign-loops  -falign-labels -fcaller-saves -fcrossjumping -fcse-follow-jumps  -fcse-skip-blocks -fdelete-null-pointer-checks -fdevirtualize -fexpensive-optimizations -fgcse  -fgcse-lm  -fhoist-adjacent-loads -finline-small-functions -findirect-inlining -fipa-sra -foptimize-sibling-calls -fpartial-inlining -fpeephole2 -fregmove  -freorder-blocks  -freorder-functions -frerun-cse-after-loop -fsched-interblock  -fsched-spec …

因此,我希望通过在比较之前不将变量的值复制到另一个变量中来提高程序性能的程度(这将在示例中更好地解释),并且我注意到一些奇怪的东西.我有这两个代码段:

string a = "";
for (int i = 0; i < 1000000; i++) a += 'a';

for (int i = 0; i < 1000000; i++) {
    if ('b' == a.at(i));//compare the two chars directly
}

和

string a = "";
for (int i = 0; i < 100000000; i++) a += 'a';

for (int i = 0; i < 100000000; i++) {
    char c = a.at(i);//declare a new variable
    if ('b' == c);//compare the char with the newly created …

这个问题更具概念性/理论性（与非常大的数据集的运行时间有关），所以我很抱歉没有一个最小的例子来展示。

我有一堆来自两个不同传感器的数据帧，我需要最终将它们连接成来自两个不同传感器（和）的两个非常大的数据帧，然后左连接成一个数据帧。我的数据是这样的，我也可以先加入，然后连接，或某种组合。我试图找出最有效的方法来做到这一点。df_snsr1df_snsr2

通过阅读这个 SO 答案，我知道它会pandas.concat为其所有数据帧的串联分配空间，如果您在循环中执行此操作，则可能会导致O(N**2)复制和一些主要的减速。因此，我目前首先构建一个大的数据帧列表（从文件加载），一次连接它们，然后加入两个大数据帧：

df_list = []
for file in my_pickle_files_snsr1:  # O(M) loop over M files
    df_list.append(pd.read_pickle(file))  # O(1) append, M times
df_snsr1 = pd.concat(df_list)  # O(N) copies of N records
# repeat for sensor 2 (df_snsr2)
df_snsr1.join(df_snsr2, on=['some', 'columns'])  # O(dunno, maybe bears?)

我无法在pandas.DataFrame.join. 是O(N)吗？O(N**2)? 我的想法是，如果它的顺序与 相似pandas.concat，那么我执行这两个操作的顺序真的无关紧要。O(N**2)但是，如果是，那么加入许多小数据帧然后连接对我来说可能会更有效他们而不是 concat 然后加入。整个操作需要足够长的时间，值得我在这里提出问题，所以“运行它并查看”是行不通的。

有人知道join正在使用什么算法以及它的执行大 O 顺序是什么吗？或者有人对获得最有效的join和组合有任何其他建议concat …

我正在研究 python，并遇到了一些查找代码的统计信息和执行时间的概念

假设我有以下代码

from time import gmtime, strftime
import timeit


def calculation():
     a = 2
     b = 3
     res = a + b
     return  res

if 'name' == 'main' :
    exec_time = timeit.timeit(calculation)
    print exec_time

结果：

0.2561519145965576

所以从上面的代码我可以找到代码的执行时间，但是如何在python中找到代码的统计信息呢？

最后我的意图如下

1. 如何在python中查找代码的统计信息
2. 如何在python中找到整个代码的执行时间
3. 代码统计实际上意味着什么？

编辑后的代码：

例如我的文件中有上面的代码test.py

现在我已经使用下面的命令运行了上面的文件

python -m cProfile test.py

结果 ：

sh-4.2$ python -m cProfile test.py
         4 function calls in 0.001 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.001    0.001    0.001    0.001 test.py:1(<module>)
        1 …