javascript

java

python

c#

android

c++

node.js

php

html

jquery

reactjs

ios

css

.net

git

ruby-on-rails

sql

c

string

ruby

performancecounter-性能计数器对性能的影响是什么

当考虑使用性能计数器作为我公司基于.NET的站点时,我想知道使用它们的开销是多少。

我是否要让我的网站不断更新其计数器,还是最好仅在进行测量时才这样做?

trans by 2020-08-03T14:16:21Z

mysql-即使使用where子句,“ SELECT COUNT(*)”也很慢

我试图弄清楚如何在MySQL中优化一个非常慢的查询(我没有设计这个):

SELECT COUNT(*) FROM change_event me WHERE change_event_id > '1212281603783391';
+----------+
| COUNT(*) |
+----------+
|  3224022 |
+----------+
1 row in set (1 min 0.16 sec)

比较一下:

select count(*) from change_event;
+----------+
| count(*) |
+----------+
|  6069102 |
+----------+
1 row in set (4.21 sec)

说明语句对我没有帮助:

 explain SELECT COUNT(*) FROM change_event me WHERE change_event_id > '1212281603783391'\G
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: me
         type: range
possible_keys: PRIMARY
          key: PRIMARY
      key_len: 8
          ref: NULL
         rows: 4120213
        Extra: Using where; Using index
1 row in set (0.00 sec)

好的,它仍然认为它需要大约400万个条目才能计数,但是我可以计算文件中的行数比这还要快! 我不明白为什么MySQL要花这么长时间。

这是表的定义:

CREATE TABLE `change_event` (
  `change_event_id` bigint(20) NOT NULL default '0',
  `timestamp` datetime NOT NULL,
  `change_type` enum('create','update','delete','noop') default NULL,
  `changed_object_type` enum('Brand','Broadcast','Episode','OnDemand') NOT NULL,
  `changed_object_id` varchar(255) default NULL,
  `changed_object_modified` datetime NOT NULL default '1000-01-01 00:00:00',
  `modified` datetime NOT NULL default '1000-01-01 00:00:00',
  `created` datetime NOT NULL default '1000-01-01 00:00:00',
  `pid` char(15) default NULL,
  `episode_pid` char(15) default NULL,
  `import_id` int(11) NOT NULL,
  `status` enum('success','failure') NOT NULL,
  `xml_diff` text,
  `node_digest` char(32) default NULL,
  PRIMARY KEY  (`change_event_id`),
  KEY `idx_change_events_changed_object_id` (`changed_object_id`),
  KEY `idx_change_events_episode_pid` (`episode_pid`),
  KEY `fk_import_id` (`import_id`),
  KEY `idx_change_event_timestamp_ce_id` (`timestamp`,`change_event_id`),
  KEY `idx_change_event_status` (`status`),
  CONSTRAINT `fk_change_event_import` FOREIGN KEY (`import_id`) REFERENCES `import` (`import_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

版:

$ mysql --version
mysql  Ver 14.12 Distrib 5.0.37, for pc-solaris2.8 (i386) using readline 5.0

有什么明显的我想念的东西吗? (是的,我已经尝试过“ SELECT COUNT(change_event_id)”,但是没有性能差异)。

trans by 2020-08-03T05:45:48Z

性能-在Postgres中创建索引的最有效方法

在完成数据加载之前或之后创建索引是否更有效,还是没关系?

例如,假设我有500个文件要加载到Postgres 8.4 DB中。 这是我可以使用的两种索引创建方案:

  1. 创建表时创建索引,然后将每个文件加载到表中; 要么
  2. 将所有文件加载到表中之后创建索引。

表数据本身大约为45 GB。 该索引约为12 GB。 我正在使用标准索引。 它是这样创建的:

CREATE INDEX idx_name ON table_name (column_name);

我的数据加载使用COPY FROM。

加载完所有文件后,表上将不会进行任何更新,删除或其他加载(一天的数据量不会改变)。 所以我想问问哪种方案最有效? 初步测试似乎表明加载所有文件然后创建索引(方案2)的速度更快,但我尚未对这两种方法进行科学比较。

trans by 2020-08-03T01:58:13Z

delphi-屏幕上有很多控件时,严重的FireMonkey性能问题

我们在办公室使用FireMonkey已经有一段时间了。 一段时间后,我们注意到Embarcadero告诉我们,由于GPU加速,它并不是那么快。

因此,我们构建了一个仅用于测试FireMonkey性能的基本应用程序。 基本上,这是一个在底部具有面板(alBottom)的面板,该面板用作状态栏和一个所有客户端(alClient)面板。 底部的面板上有一个进度条和一个动画。

我们向表单添加了一种方法,以释放所有客户端面板中存在的所有控件,并使用自定义类型和“鼠标悬停”样式的单元格来实现它,并使用有关以下信息的信息更新动画,进度条和表单标题 取得进展。 最重要的信息是所需的时间。

最后,我们将这种方法添加到窗体的OnResize中,运行应用程序并使窗体最大化(1280x1024)。

XE2的结果确实很慢。 花了大约11秒。 另外,由于在完成应用程序准备好接收用户输入之前面板已完成,因此存在大约10秒的额外延迟(例如冻结)。 总共21秒。

使用XE3,情况变得最糟。 对于同一操作,总共花费了25秒(14 + 11冻结)。

有传言称XE4将会比XE3糟糕得多。

考虑到完全相同的应用程序,使用VCL代替FireMonkey并使用SpeedButton来获得相同的“鼠标过效果”,只需1.5秒,这真是令人恐惧! 因此,问题显然出在某些内部FireMonkey引擎问题上。

我开了一个质量控制中心(#113795)和一张(收费的)机票以获取embarcadero的支持,但是他们什么也解决不了。

我严重不明白他们怎么能忽略这么重的问题。 对于我们的企业来说,这是一个秀场终结者和交易破坏者。 我们不能为性能如此差的客户提供商业软件。 迟早我们将被迫转移到另一个平台(顺便说一句:使用WPF的相同代码Delphi Prism与VCL一样需要1.5秒)。

如果有人对如何解决该问题或尝试改善此测试性能有任何想法,并且想提供帮助,我将非常高兴。

先感谢您。

布鲁诺·弗拉蒂尼(Bruno Fratini)

该应用程序如下:

unit Performance01Main;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Rtti, System.Classes,
  System.Variants, FMX.Types, FMX.Controls, FMX.Forms, FMX.Dialogs, FMX.Objects;

const
  cstCellWidth = 45;
  cstCellHeight = 21;

type

  TCell = class(TStyledControl)
  private
    function GetText: String;
    procedure SetText(const Value: String);
    function GetIsFocusCell: Boolean;
  protected
    FSelected: Boolean;
    FMouseOver: Boolean;
    FText: TText;
    FValue: String;
    procedure ApplyStyle; override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure DoMouseEnter; override;
    procedure DoMouseLeave; override;
    procedure ApplyTrigger(TriggerName: string);
  published
    property IsSelected: Boolean read FSelected;
    property IsFocusCell: Boolean read GetIsFocusCell;
    property IsMouseOver: Boolean read FMouseOver;
    property Text: String read GetText write SetText;
  end;

  TFormFireMonkey = class(TForm)
    StyleBook: TStyleBook;
    BottomPanel: TPanel;
    AniIndicator: TAniIndicator;
    ProgressBar: TProgressBar;
    CellPanel: TPanel;
    procedure FormResize(Sender: TObject);
    procedure FormActivate(Sender: TObject);
  protected
    FFocused: TCell;
    FEntered: Boolean;
  public
    procedure CreateCells;
  end;

var
  FormFireMonkey: TFormFireMonkey;

implementation

uses
  System.Diagnostics;

{$R *.fmx}

{ TCell }

procedure TCell.ApplyStyle;
begin
  inherited;
  ApplyTrigger('IsMouseOver');
  ApplyTrigger('IsFocusCell');
  ApplyTrigger('IsSelected');
  FText:= (FindStyleResource('Text') as TText);
  if (FText <> Nil) then
    FText.Text := FValue;
end;

procedure TCell.ApplyTrigger(TriggerName: string);
begin
  StartTriggerAnimation(Self, TriggerName);
  ApplyTriggerEffect(Self, TriggerName);
end;

procedure TCell.DoMouseEnter;
begin
  inherited;
  FMouseOver:= True;
  ApplyTrigger('IsMouseOver');
end;

procedure TCell.DoMouseLeave;
begin
  inherited;
  FMouseOver:= False;
  ApplyTrigger('IsMouseOver');
end;

function TCell.GetIsFocusCell: Boolean;
begin
  Result:= (Self = FormFireMonkey.FFocused);
end;

function TCell.GetText: String;
begin
  Result:= FValue;
end;

procedure TCell.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
var
  OldFocused: TCell;
begin
  inherited;
  FSelected:= not(FSelected);
  OldFocused:= FormFireMonkey.FFocused;
  FormFireMonkey.FFocused:= Self;
  ApplyTrigger('IsFocusCell');
  ApplyTrigger('IsSelected');
  if (OldFocused <> Nil) then
    OldFocused.ApplyTrigger('IsFocusCell');
end;

procedure TCell.SetText(const Value: String);
begin
  FValue := Value;
  if Assigned(FText) then
    FText.Text:= Value;
end;

{ TForm1 }

procedure TFormFireMonkey.CreateCells;
var
  X, Y: Double;
  Row, Col: Integer;
  Cell: TCell;
  T: TTime;
  // Workaround suggested by Himself 1
  // Force update only after a certain amount of iterations
  // LP: Single;

  // Workaround suggested by Himself 2
  // Force update only after a certain amount of milliseconds
  // Used cross-platform TStopwatch as suggested by LU RD
  // Anyway the same logic was tested with TTime and GetTickCount
  // SW: TStopWatch;

begin
  T:= Time;
  Caption:= 'Creating cells...';

  {$REGION 'Issue 2 workaround: Update form size and background'}
  // Bruno Fratini:
  // Without (all) this code the form background and area is not updated till the
  // cells calculation is finished
  BeginUpdate;
  Invalidate;
  EndUpdate;
  // Workaround suggested by Philnext
  // replacing ProcessMessages with HandleMessage
  // Application.HandleMessage;
  Application.ProcessMessages;
  {$ENDREGION}

  // Bruno Fratini:
  // Update starting point step 1
  // Improving performance
  CellPanel.BeginUpdate;

  // Bruno Fratini:
  // Freeing the previous cells (if any)
  while (CellPanel.ControlsCount > 0) do
    CellPanel.Controls[0].Free;

  // Bruno Fratini:
  // Calculating how many rows and columns can contain the CellPanel
  Col:= Trunc(CellPanel.Width / cstCellWidth);
  if (Frac(CellPanel.Width / cstCellWidth) > 0) then
    Col:= Col + 1;
  Row:= Trunc(CellPanel.Height / cstCellHeight);
  if (Frac(CellPanel.Height / cstCellHeight) > 0) then
    Row:= Row + 1;

  // Bruno Fratini:
  // Loop variables initialization
  ProgressBar.Value:= 0;
  ProgressBar.Max:= Row * Col;
  AniIndicator.Enabled:= True;
  X:= 0;
  Col:= 0;

  // Workaround suggested by Himself 2
  // Force update only after a certain amount of milliseconds
  // Used cross-platform TStopwatch as suggested by LU RD
  // Anyway the same logic was tested with TTime and GetTickCount
  // SW:= TStopwatch.StartNew;

  // Workaround suggested by Himself 1
  // Force update only after a certain amount of iterations
  // LP:= 0;

  // Bruno Fratini:
  // Loop for fulfill the Width
  while (X < CellPanel.Width) do
  begin
    Y:= 0;
    Row:= 0;
    // Bruno Fratini:
    // Loop for fulfill the Height
    while (Y < CellPanel.Height) do
    begin
      // Bruno Fratini:
      // Cell creation and bounding into the CellPanel
      Cell:= TCell.Create(CellPanel);
      Cell.Position.X:= X;
      Cell.Position.Y:= Y;
      Cell.Width:= cstCellWidth;
      Cell.Height:= cstCellHeight;
      Cell.Parent:= CellPanel;

      // Bruno Fratini:
      // Assigning the style that gives something like Windows 7 effect
      // on mouse move into the cell
      Cell.StyleLookup:= 'CellStyle';

      // Bruno Fratini:
      // Updating loop variables and visual controls for feedback
      Y:= Y + cstCellHeight;
      Row:= Row + 1;
      ProgressBar.Value:= ProgressBar.Value + 1;
      // Workaround suggested by Himself 1
      // Force update only after a certain amount of iterations
      // if ((ProgressBar.Value - LP) >= 100) then

      // Workaround suggested by Himself 2
      // Force update only after a certain amount of milliseconds
      // Used cross-platform TStopwatch as suggested by LU RD
      // Anyway the same logic was tested with TTime and GetTickCount
      // if (SW.ElapsedMilliseconds >= 30) then

      // Workaround suggested by Philnext with Bruno Fratini's enhanchment
      // Skip forcing refresh when the form is not focused for the first time
      // This avoid the strange side effect of overlong delay on form open
      // if FEntered then
      begin
        Caption:= 'Elapsed time: ' + FormatDateTime('nn:ss:zzz', Time - T) +
                  ' (min:sec:msec) Cells: ' + IntToStr(Trunc(ProgressBar.Value));

        {$REGION 'Issue 4 workaround: Forcing progress and animation visual update'}
        // Bruno Fratini:
        // Without the ProcessMessages call both the ProgressBar and the
        // Animation controls are not updated so no feedback to the user is given
        // that is not acceptable. By the other side this introduces a further
        // huge delay on filling the grid to a not acceptable extent
        // (around 20 minutes on our machines between form maximization starts and
        // it arrives to a ready state)

        // Workaround suggested by Philnext
        // replacing ProcessMessages with HandleMessage
        // Application.HandleMessage;
        Application.ProcessMessages;
        {$ENDREGION}

        // Workaround suggested by Himself 1
        // Force update only after a certain amount of iterations
        // LP:= ProgressBar.Value;

        // Workaround suggested by Himself 2
        // Force update only after a certain amount of milliseconds
        // Used cross-platform TStopwatch as suggested by LU RD
        // Anyway the same logic was tested with TTime and GetTickCount
        // SW.Reset;
        // SW.Start;
      end;
    end;
    X:= X + cstCellWidth;
    Col:= Col + 1;
  end;

  // Bruno Fratini:
  // Update starting point step 2
  // Improving performance
  CellPanel.EndUpdate;

  AniIndicator.Enabled:= False;
  ProgressBar.Value:= ProgressBar.Max;
  Caption:= 'Elapsed time: ' + FormatDateTime('nn:ss:zzz', Time - T) +
            ' (min:sec:msec) Cells: ' + IntToStr(Trunc(ProgressBar.Value));

  // Bruno Fratini:
  // The following lines are required
  // otherwise the cells won't be properly paint after maximizing
  BeginUpdate;
  Invalidate;
  EndUpdate;
  // Workaround suggested by Philnext
  // replacing ProcessMessages with HandleMessage
  // Application.HandleMessage;
  Application.ProcessMessages;
end;

procedure TFormFireMonkey.FormActivate(Sender: TObject);
begin
  // Workaround suggested by Philnext with Bruno Fratini's enhanchment
  // Skip forcing refresh when the form is not focused for the first time
  // This avoid the strange side effect of overlong delay on form open
  FEntered:= True;
end;

procedure TFormFireMonkey.FormResize(Sender: TObject);
begin
  CreateCells;
end;

end.
trans by 2020-08-02T05:12:41Z

性能-C ++中的CPU节流

我只是想知道是否有一种优雅的方法来为执行密集计算的特定线程设置最大CPU负载。

现在,我在线程中找到了最耗时的循环(它仅压缩),并使用GetTickCount()Sleep()以及硬编码值。 它可以确保循环持续一定时间,然后休眠一定的最短时间。 这项工作或多或少地完成了工作,即保证线程使用的CPU不超过50%。
但是,行为取决于CPU内核的数量(巨大的劣势),而仅仅是丑陋的(较小的劣势:))。
有任何想法吗?

trans by 2020-07-31T20:54:01Z

android-增强webView的性能(应该与本机Web浏览器的性能相同)

我的经验是,在WebView中加载网站比在Android Web浏览器中执行相同操作要慢得多。 我可以看到所有文件都已加载到我的Apache日志中,但是要花几秒钟才能在WebView控件中显示该页面。 在本机Web浏览器中打开同一页面将立即显示。 渲染似乎被削弱了。

为了获得与在本机Web浏览器中加载页面相同的性能,我们必须应用哪些浏览器设置?

我们当前的设置:

browserset.setLoadsImagesAutomatically(true);
browserset.setJavaScriptEnabled(true);
browserset.setDatabaseEnabled(true);
browserset.setDatabasePath("data/data/com.xxx/databases");
browserset.setDomStorageEnabled(true);
browserset.setRenderPriority(WebSettings.RenderPriority.HIGH);
browserset.setSupportZoom(false);
browserset.setUserAgentString( browserset.getUserAgentString() + " (XY ClientApp)" );
browserset.setAllowFileAccess(true);
browserset.setSavePassword(false);
browserset.setSupportMultipleWindows(false);
browserset.setAppCacheEnabled(true);
browserset.setAppCachePath("");
browserset.setAppCacheMaxSize(5*1024*1024);
trans by 2020-07-30T19:37:48Z

java-新TLAB中的分配与TLAB之外的分配

JDK中的Java Mission Control工具提供有关新TLAB中对象分配以及TLAB外部分配的统计信息。 (在“内存/分配”下)。 这些统计信息的意义是什么,对于应用程序的性能有什么好处? 我是否应该担心是否在TLAB之外分配了一些对象,如果可以,该怎么办?

trans by 2020-07-30T09:15:43Z

脚本-最快的“获取重复项” SQL脚本

快速SQL的示例是如何在具有成千上万条记录的数据集中获取重复项。 我通常使用类似:

SELECT afield1, afield2 FROM afile a 
WHERE 1 < (SELECT count(afield1) FROM afile b WHERE a.afield1 = b.afield1);

但这很慢。

trans by 2020-07-30T02:06:47Z

postgresql-将Python的Postgres psycopg2查询性能提高到与Java JDBC dri相同的水平

总览

我正在尝试改善SQLAlchemy数据库查询的性能。 我们正在使用psycopg2。 在我们的生产系统中,我们选择Java,因为Java的运行速度至少快了50%,甚至还不到100%。 因此,我希望Stack Overflow社区中的某人能够改善我的性能。

我认为下一步是结束修补psycopg2库,使其表现得像JDBC驱动程序。 如果是这样,并且有人已经做到了,那很好,但是我希望我仍然可以通过Python进行设置或重构调整。

细节

我有一个简单的“ SELECT * FROM someLargeDataSetTable”查询正在运行。 数据集的大小为GB。 快速性能图如下:

时序表

        Records    | JDBC  | SQLAlchemy[1] |  SQLAlchemy[2] |  Psql
-------------------------------------------------------------------- 
         1 (4kB)   | 200ms |         300ms |          250ms |   10ms
        10 (8kB)   | 200ms |         300ms |          250ms |   10ms
       100 (88kB)  | 200ms |         300ms |          250ms |   10ms
     1,000 (600kB) | 300ms |         300ms |          370ms |  100ms
    10,000 (6MB)   | 800ms |         830ms |          730ms |  850ms  
   100,000 (50MB)  |    4s |            5s |           4.6s |     8s
 1,000,000 (510MB) |   30s |           50s |            50s |  1m32s  
10,000,000 (5.1GB) | 4m44s |         7m55s |          6m39s |    n/a
-------------------------------------------------------------------- 
 5,000,000 (2.6GB) | 2m30s |         4m45s |          3m52s | 14m22s
-------------------------------------------------------------------- 
[1] - With the processrow function
[2] - Without the processrow function (direct dump)

我可以添加更多的数据(我们的数据可以达到TB),但是我认为数据的斜率变化很明显。 随着数据集大小的增加,JDBC的性能将显着提高。 一些注意事项...

时序表注释:

  • 数据大小是近似值,但是它们应该使您对数据量有所了解。
  • 我正在从Linux bash命令行使用“时间”工具。
  • 该时间是挂钟时间(即真实时间)。
  • 我正在使用Python 2.6.6,并且正在运行python -u
  • 提取大小为10,000
  • 我并不真正担心Psql的计时,它只是作为参考。 我可能没有正确设置fetchsize。
  • 我也真的不担心低于fetch大小的时间,因为不到5秒对我的应用程序可以忽略不计。
  • Java和Psql似乎占用大约1GB的内存资源。 Python更像是100MB(是的!)。
  • 我正在使用[cdecimals]库。
  • 我注意到[最近的文章]在讨论与此类似的内容。 看来JDBC驱动程序设计与psycopg2设计完全不同(鉴于性能差异,我认为这很烦人)。
  • 我的用例基本上是我必须在非常大的数据集上运行每日过程(大约20,000个不同的步骤...多个查询),并且我有一个非常特定的时间范围可以完成此过程。 我们使用的Java不仅仅是JDBC,它是JDBC引擎之上的“智能”包装器……我们不想使用Java,而我们想停止使用Java的“智能”部分。
  • 我正在使用生产系统的其中一个框(数据库和后端进程)来运行查询。 这是我们最好的时机。 QA和Dev框的运行速度要慢得多,而且额外的查询时间会变得很长。

testSqlAlchemy.py

#!/usr/bin/env python
# testSqlAlchemy.py
import sys
try:
    import cdecimal
    sys.modules["decimal"]=cdecimal
except ImportError,e:
    print >> sys.stderr, "Error: cdecimal didn't load properly."
    raise SystemExit
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

def processrow (row,delimiter="|",null="\N"):
    newrow = []
    for x in row:
        if x is None:
            x = null
        newrow.append(str(x))
    return delimiter.join(newrow)

fetchsize = 10000
connectionString = "postgresql+psycopg2://usr:pass@server:port/db"
eng = create_engine(connectionString, server_side_cursors=True)
session = sessionmaker(bind=eng)()

with open("test.sql","r") as queryFD:
   with open("/dev/null","w") as nullDev:
        query = session.execute(queryFD.read())
        cur = query.cursor
        while cur.statusmessage not in ['FETCH 0','CLOSE CURSOR']:
            for row in query.fetchmany(fetchsize):
                print >> nullDev, processrow(row)

在计时之后,我还运行了一个cProfile,这是最严重的违规者的转储:

时序配置文件(带有过程行)

Fri Mar  4 13:49:45 2011    sqlAlchemy.prof

         415757706 function calls (415756424 primitive calls) in 563.923 CPU seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.001    0.001  563.924  563.924 {execfile}
        1   25.151   25.151  563.924  563.924 testSqlAlchemy.py:2()
     1001    0.050    0.000  329.285    0.329 base.py:2679(fetchmany)
     1001    5.503    0.005  314.665    0.314 base.py:2804(_fetchmany_impl)
 10000003    4.328    0.000  307.843    0.000 base.py:2795(_fetchone_impl)
    10011    0.309    0.000  302.743    0.030 base.py:2790(__buffer_rows)
    10011  233.620    0.023  302.425    0.030 {method 'fetchmany' of 'psycopg2._psycopg.cursor' objects}
 10000000  145.459    0.000  209.147    0.000 testSqlAlchemy.py:13(processrow)

时序配置文件(无进程行)

Fri Mar  4 14:03:06 2011    sqlAlchemy.prof

         305460312 function calls (305459030 primitive calls) in 536.368 CPU seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.001    0.001  536.370  536.370 {execfile}
        1   29.503   29.503  536.369  536.369 testSqlAlchemy.py:2()
     1001    0.066    0.000  333.806    0.333 base.py:2679(fetchmany)
     1001    5.444    0.005  318.462    0.318 base.py:2804(_fetchmany_impl)
 10000003    4.389    0.000  311.647    0.000 base.py:2795(_fetchone_impl)
    10011    0.339    0.000  306.452    0.031 base.py:2790(__buffer_rows)
    10011  235.664    0.024  306.102    0.031 {method 'fetchmany' of 'psycopg2._psycopg.cursor' objects}
 10000000   32.904    0.000  172.802    0.000 base.py:2246(__repr__)

最后评论

不幸的是,除非SQLAlchemy中有一种方法可以指定输出的null ='userDefinedValueOrString'和delimiter ='userDefinedValueOrString',否则processrow函数需要保留。 我们目前使用的Java已经做到了这一点,因此比较(与processrow)必须是苹果与苹果。 如果有一种方法可以通过纯Python或设置调整来提高processrow或SQLAlchemy的性能,我非常感兴趣。

trans by 2020-07-29T15:01:46Z

性能-R中的预分配列表

R在循环中扩展数据结构效率不高。 如何预分配一定大小的listmatrix通过ncolnrow参数使此操作变得容易。 如何在清单中做到这一点? 例如:

x <- list()
for (i in 1:10) {
    x[[i]] <- i
}

我认为这是低效的。 有什么更好的方法可以做到这一点?

trans by 2020-07-27T09:48:38Z

性能-具体而言,CSS是否更快?

div.container比.container快吗?您知道像jquery一样,如果您对选择器更具体,则它会更快,因为它迭代的次数更少。css是这种情况吗?

有没有一种方法可以衡量CSS的性能?在性能方面,这样的事情是否重要还是基本上取决于文本的粗细?

如果有人知道答案,我会很高兴,但实际上我找到了类似的问题,但没有确定的答案。如果更好地指定CSS,可以提高效率吗?

trans by 2020-07-27T01:08:54Z

C ++-Linux性能:如何解释和查找热点

我今天尝试了linux的perf实用程序,但在解释其结果时遇到了麻烦。 我习惯了valgrind的callgrind,这当然是与基于perf的采样方法完全不同的方法。

我做了什么:

perf record -g -p $(pidof someapp)
perf report -g -n

现在我看到这样的事情:

+     16.92%  kdevelop  libsqlite3.so.0.8.6               [.] 0x3fe57                                                                                                              ↑
+     10.61%  kdevelop  libQtGui.so.4.7.3                 [.] 0x81e344                                                                                                             ▮
+      7.09%  kdevelop  libc-2.14.so                      [.] 0x85804                                                                                                              ▒
+      4.96%  kdevelop  libQtGui.so.4.7.3                 [.] 0x265b69                                                                                                             ▒
+      3.50%  kdevelop  libQtCore.so.4.7.3                [.] 0x18608d                                                                                                             ▒
+      2.68%  kdevelop  libc-2.14.so                      [.] memcpy                                                                                                               ▒
+      1.15%  kdevelop  [kernel.kallsyms]                 [k] copy_user_generic_string                                                                                             ▒
+      0.90%  kdevelop  libQtGui.so.4.7.3                 [.] QTransform::translate(double, double)                                                                                ▒
+      0.88%  kdevelop  libc-2.14.so                      [.] __libc_malloc                                                                                                        ▒
+      0.85%  kdevelop  libc-2.14.so                      [.] memcpy 
...

好的,这些功能可能很慢,但是如何找出从哪里调用这些功能? 由于所有这些热点都位于外部库中,因此我看不到优化代码的方法。

基本上,我正在寻找一种带有累计成本的标注的callgraph,其中我的函数比我调用的库函数具有更高的包含采样成本。

性能有可能吗? 如果是这样-如何?

注意:我发现“ E”展开了调用图,并提供了更多信息。 但是,调用图通常不够深和/或随机终止,而没有提供有关在哪里花费了多少信息的信息。 例:

-     10.26%  kate  libkatepartinterfaces.so.4.6.0  [.] Kate::TextLoader::readLine(int&...
     Kate::TextLoader::readLine(int&, int&)                                            
     Kate::TextBuffer::load(QString const&, bool&, bool&)                              
     KateBuffer::openFile(QString const&)                                              
     KateDocument::openFile()                                                          
     0x7fe37a81121c

我在64位上运行是否会成为问题? 另请参见:[http://lists.fedoraproject.org/pipermail/devel/2010-November/144952.html](我没有使用fedora,但似乎适用于所有64位系统)。

trans by 2020-07-26T18:26:12Z

sql-MySQL说明计划中“选择已优化的表”的含义

MySQL Explain plan中的explain plan是什么意思?

explain select count(comment_count) from wp_posts;

+----+-------------+---------------------------+-----------------------------+
| id | select_type | table,type,possible_keys, | Extra                       |
|    |             | key,key_len,ref,rows      |                             |
+----+-------------+---------------------------+-----------------------------+
| 1  | SIMPLE      | all NULLs                 | Select tables optimized away| 
+----+-------------+---------------------------+-----------------------------+
1 row in set (0.00 sec)

注意:编辑了explain plan输出以提高可读性。

trans by 2020-07-26T18:05:33Z

使用AVX内在函数而不是SSE不能提高速度-为什么?

我使用Intel的SSE内部函数已有相当长的一段时间,并获得了不错的性能提升。 因此,我期望AVX内在函数可以进一步加快程序速度。 不幸的是,到目前为止,情况并非如此。 可能是我犯了一个愚蠢的错误,所以如果有人可以帮助我,我将不胜感激。

我在g ++ 4.6.1中使用Ubuntu 11.10。 我用以下命令编译了程序(见下文)

g++ simpleExample.cpp -O3 -march=native -o simpleExample

测试系统具有Intel i7-2600 CPU。

这是示例我的问题的代码。 在我的系统上,我得到了输出

98.715 ms, b[42] = 0.900038 // Naive
24.457 ms, b[42] = 0.900038 // SSE
24.646 ms, b[42] = 0.900038 // AVX

请注意,选择计算sqrt(sqrt(sqrt(x)))只是为了确保内存带宽不会限制执行速度。 这只是一个例子。

simpleExample.cpp:

#include <immintrin.h>
#include <iostream>
#include <math.h> 
#include <sys/time.h>

using namespace std;

// -----------------------------------------------------------------------------
// This function returns the current time, expressed as seconds since the Epoch
// -----------------------------------------------------------------------------
double getCurrentTime(){
  struct timeval curr;
  struct timezone tz;
  gettimeofday(&curr, &tz);
  double tmp = static_cast<double>(curr.tv_sec) * static_cast<double>(1000000)
             + static_cast<double>(curr.tv_usec);
  return tmp*1e-6;
}

// -----------------------------------------------------------------------------
// Main routine
// -----------------------------------------------------------------------------
int main() {

  srand48(0);            // seed PRNG
  double e,s;            // timestamp variables
  float *a, *b;          // data pointers
  float *pA,*pB;         // work pointer
  __m128 rA,rB;          // variables for SSE
  __m256 rA_AVX, rB_AVX; // variables for AVX

  // define vector size 
  const int vector_size = 10000000;

  // allocate memory 
  a = (float*) _mm_malloc (vector_size*sizeof(float),32);
  b = (float*) _mm_malloc (vector_size*sizeof(float),32);

  // initialize vectors //
  for(int i=0;i<vector_size;i++) {
    a[i]=fabs(drand48());
    b[i]=0.0f;
  }

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Naive implementation
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  s = getCurrentTime();
  for (int i=0; i<vector_size; i++){
    b[i] = sqrtf(sqrtf(sqrtf(a[i])));
  }
  e = getCurrentTime();
  cout << (e-s)*1000 << " ms" << ", b[42] = " << b[42] << endl;

// -----------------------------------------------------------------------------
  for(int i=0;i<vector_size;i++) {
    b[i]=0.0f;
  }
// -----------------------------------------------------------------------------

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// SSE2 implementation
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  pA = a; pB = b;

  s = getCurrentTime();
  for (int i=0; i<vector_size; i+=4){
    rA   = _mm_load_ps(pA);
    rB   = _mm_sqrt_ps(_mm_sqrt_ps(_mm_sqrt_ps(rA)));
    _mm_store_ps(pB,rB);
    pA += 4;
    pB += 4;
  }
  e = getCurrentTime();
  cout << (e-s)*1000 << " ms" << ", b[42] = " << b[42] << endl;

// -----------------------------------------------------------------------------
  for(int i=0;i<vector_size;i++) {
    b[i]=0.0f;
  }
// -----------------------------------------------------------------------------

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// AVX implementation
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  pA = a; pB = b;

  s = getCurrentTime();
  for (int i=0; i<vector_size; i+=8){
    rA_AVX   = _mm256_load_ps(pA);
    rB_AVX   = _mm256_sqrt_ps(_mm256_sqrt_ps(_mm256_sqrt_ps(rA_AVX)));
    _mm256_store_ps(pB,rB_AVX);
    pA += 8;
    pB += 8;
  }
  e = getCurrentTime();
  cout << (e-s)*1000 << " ms" << ", b[42] = " << b[42] << endl;

  _mm_free(a);
  _mm_free(b);

  return 0;
}

任何帮助表示赞赏!

trans by 2020-07-26T17:50:06Z

插入到向量中的前面

iterator insert ( iterator position, const T& x );

std::Vector类的插入运算符的函数声明。

该函数的返回类型是指向插入元素的迭代器。 我的问题是,考虑到这种返回类型,一开始插入的最有效方法是什么(这是我正在运行的大型程序的一部分,其中速度是至关重要的,所以我正在寻找计算效率最高的方法)。 是下面吗?

//Code 1
vector<int> intvector;
vector<int>::iterator it;
it = myvector.begin();
for(int i = 1; i <= 100000; i++){
    it = intvector.insert(it,i);
}

要么,

//Code 2
vector<int> intvector;
for(int i = 1; i <= 100000; i++){
    intvector.insert(intvector.begin(),i);
}

本质上,在代码2中,参数是

intvector.begin() 

与在代码1中使用返回的迭代器相比,“按成本计算”进行计算评估还是应该两者都同样便宜/昂贵?

trans by 2020-07-26T16:42:36Z

性能-Scala函数式编程是否比传统编码慢?

在我第一次创建功能代码的尝试中,我遇到了一个性能问题。

我从一个常见的任务开始-将两个数组的元素相乘并得出结果:

var first:Array[Float] ...
var second:Array[Float] ...    
var sum=0f; 
for (ix<-0 until first.length) 
    sum += first(ix) * second(ix);

这是我改革工作的方式:

sum = first.zip(second).map{ case (a,b) => a*b }.reduceLeft(_+_)

当我对这两种方法进行基准测试时,第二种方法需要40倍的时间才能完成!

为什么第二种方法需要这么长时间? 我如何才能使工作既高效又能使用函数式编程风格呢?

trans by 2020-07-26T16:21:08Z

java-什么时候应该比传统循环更喜欢流来获得最佳性能? 流是否利用分支预测?

我刚刚阅读了Branch-Prediction,想尝试一下Java 8 Streams的工作原理。

但是,Streams的性能总是比传统循环差。

int totalSize = 32768;
int filterValue = 1280;
int[] array = new int[totalSize];
Random rnd = new Random(0);
int loopCount = 10000;

for (int i = 0; i < totalSize; i++) {
    // array[i] = rnd.nextInt() % 2560; // Unsorted Data
    array[i] = i; // Sorted Data
}

long start = System.nanoTime();
long sum = 0;
for (int j = 0; j < loopCount; j++) {
    for (int c = 0; c < totalSize; ++c) {
        sum += array[c] >= filterValue ? array[c] : 0;
    }
}
long total = System.nanoTime() - start;
System.out.printf("Conditional Operator Time : %d ns, (%f sec) %n", total, total / Math.pow(10, 9));

start = System.nanoTime();
sum = 0;
for (int j = 0; j < loopCount; j++) {
    for (int c = 0; c < totalSize; ++c) {
        if (array[c] >= filterValue) {
            sum += array[c];
        }
    }
}
total = System.nanoTime() - start;
System.out.printf("Branch Statement Time : %d ns, (%f sec) %n", total, total / Math.pow(10, 9));

start = System.nanoTime();
sum = 0;
for (int j = 0; j < loopCount; j++) {
    sum += Arrays.stream(array).filter(value -> value >= filterValue).sum();
}
total = System.nanoTime() - start;
System.out.printf("Streams Time : %d ns, (%f sec) %n", total, total / Math.pow(10, 9));

start = System.nanoTime();
sum = 0;
for (int j = 0; j < loopCount; j++) {
    sum += Arrays.stream(array).parallel().filter(value -> value >= filterValue).sum();
}
total = System.nanoTime() - start;
System.out.printf("Parallel Streams Time : %d ns, (%f sec) %n", total, total / Math.pow(10, 9));

输出:

  1. 对于排序数组:

    Conditional Operator Time : 704120976 ns, (0.704121 sec) 
    Branch Statement Time : 1327838248 ns, (1.327838 sec) 
    Streams Time : 1857880764 ns, (1.857881 sec) 
    Parallel Streams Time : 2504468688 ns, (2.504469 sec) 
    
  2. 对于未排序的阵列:

    Conditional Operator Time : 704120976 ns, (0.704121 sec) 
    Branch Statement Time : 1327838248 ns, (1.327838 sec) 
    Streams Time : 1857880764 ns, (1.857881 sec) 
    Parallel Streams Time : 2504468688 ns, (2.504469 sec) 
    

我使用List尝试了相同的代码:
Conditional Operator Time : 704120976 ns, (0.704121 sec) Branch Statement Time : 1327838248 ns, (1.327838 sec) Streams Time : 1857880764 ns, (1.857881 sec) Parallel Streams Time : 2504468688 ns, (2.504469 sec) 而不是Arrays.stream(array)
list.get(c)而不是array[c]

输出:

  1. 对于排序列表:

    Conditional Operator Time : 704120976 ns, (0.704121 sec) 
    Branch Statement Time : 1327838248 ns, (1.327838 sec) 
    Streams Time : 1857880764 ns, (1.857881 sec) 
    Parallel Streams Time : 2504468688 ns, (2.504469 sec) 
    
  2. 对于未排序列表

    Conditional Operator Time : 704120976 ns, (0.704121 sec) 
    Branch Statement Time : 1327838248 ns, (1.327838 sec) 
    Streams Time : 1857880764 ns, (1.857881 sec) 
    Parallel Streams Time : 2504468688 ns, (2.504469 sec) 
    

我在此提及过很少的博客,这暗示了相同的性能问题。

  1. 我同意这样的观点,在某些情况下,使用流进行编程是很好并且更容易的方法,但是当我们在性能方面失去优势时,为什么需要使用它们呢? 有什么我想念的吗?
  2. 流在哪些情况下执行等于循环的情况? 仅在您的函数定义花费大量时间而导致循环性能可忽略不计的情况下吗?
  3. 在任何一种情况下,我都看不到流利用分支预测(我尝试使用排序流和无序流,但是没有用。与正常流相比,它对性能的影响是原来的两倍以上)?
trans by 2020-07-26T06:56:22Z

HHVM性能不佳

我正在基于代码基础上评估HipHop-PHP的兼容性和性能,但是在启用内置Web服务器的情况下运行它时,性能却很差。

我有以下示例测试程序,用于计算斐波纳契数列。

ex3.php:

function fib($n)
{
    if ($n <= 2)
        return 1;
    else
        return fib($n-1) + fib($n-2);
}

$n = 36;
printf("fib(%d) = %d\n", $n, fib($n, 2));

当我使用命令行通过HHVM运行此命令时,我得到了令人印象深刻的结果:

time hhvm -v"Eval.Jit=true" -f ./ex3.php
fib(36) = 14930352

real    0m0.267s
user    0m0.248s
sys     0m0.020s

将此与标准PHP进行比较:

root@hiphop:/www# time php -f ./ex3.php
fib(36) = 14930352

real    0m5.606s
user    0m5.600s
sys     0m0.000s    

但是,当我想在HHVM中启用内置Web服务器时,所有性能提升都将丢失:

hhvm -v"Eval.Jit=true" -m server -p 8000 &
time wget -qSO - http://localhost:8000/ex3.php
  HTTP/1.1 200 OK
  Content-Type: text/html; charset=utf-8
  X-Powered-By: HPHP
  Date: Sat, 27 Jul 2013 14:16:09 GMT
  Content-Length: 19
fib(36) = 14930352

real    0m5.279s
user    0m0.000s
sys     0m0.000s

如您所见,我从HHVM获得了响应,但是处理该请求花费了5秒钟以上。 我想念什么?

trans by 2020-07-25T07:15:28Z

为什么statistics.mean()这么慢?

我将statistics模块的2980238309705909909248功能与简单的2980238309705909909250方法的性能进行了比较,发现2980238309705909909251功能由于某些原因非常慢。 我将timeit与下面的两个代码段进行了比较,有人知道是什么导致执行速度的巨大差异吗? 我正在使用Python 3.5。

from timeit import repeat
print(min(repeat('mean(l)',
                 '''from random import randint; from statistics import mean; \
                 l=[randint(0, 10000) for i in range(10000)]''', repeat=20, number=10)))

上面的代码在我的计算机上执行约0.043秒。

from timeit import repeat
print(min(repeat('sum(l)/len(l)',
                 '''from random import randint; from statistics import mean; \
                 l=[randint(0, 10000) for i in range(10000)]''', repeat=20, number=10)))

上面的代码在我的计算机上执行大约0.000565秒。

trans by 2020-07-24T06:56:00Z

java-为什么StringBuilder链接模式sb.append(x).append(y)比常规sb.append(x)更快? sb.append(y)?

我有一个微基准测试,显示出非常奇怪的结果:

@BenchmarkMode(Mode.Throughput)
@Fork(1)
@State(Scope.Thread)
@Warmup(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS, batchSize = 1000)
@Measurement(iterations = 40, time = 1, timeUnit = TimeUnit.SECONDS, batchSize = 1000)
public class Chaining {

    private String a1 = "111111111111111111111111";
    private String a2 = "222222222222222222222222";
    private String a3 = "333333333333333333333333";

    @Benchmark
    public String typicalChaining() {
        return new StringBuilder().append(a1).append(a2).append(a3).toString();
    }

    @Benchmark
    public String noChaining() {
        StringBuilder sb = new StringBuilder();
        sb.append(a1);
        sb.append(a2);
        sb.append(a3);
        return sb.toString();
    }
}

我期望两个测试的结果相同或至少非常接近。 但是,差异几乎是5倍:

# Run complete. Total time: 00:01:41

Benchmark                  Mode  Cnt      Score     Error  Units
Chaining.noChaining       thrpt   40   8538.236 ± 209.924  ops/s
Chaining.typicalChaining  thrpt   40  36729.523 ± 988.936  ops/s

有人知道这怎么可能吗?

trans by 2020-07-23T21:52:07Z

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 下一页 共40页