Questions tagged «performance»

我们都知道，在Python中执行语句一定次数的常见方法是使用for循环。 一般的做法是 # I am assuming iterated list is redundant. # Just the number of execution matters. for _ in range(count): pass 我相信没有人会争辩说上面的代码是通用的实现，但是还有另一种选择。通过增加引用来使用Python列表创建的速度。 # Uncommon way. for _ in [0] * count: pass 还有旧的while方法。 i = 0 while i < count: i += 1 我测试了这些方法的执行时间。这是代码。 import timeit repeat = 10 …

66 python  python-3.x  performance  time-complexity 

使用列表的insert功能比使用切片分配实现相同的效果要慢得多： > python -m timeit -n 100000 -s "a=[]" "a.insert(0,0)" 100000 loops, best of 5: 19.2 usec per loop > python -m timeit -n 100000 -s "a=[]" "a[0:0]=[0]" 100000 loops, best of 5: 6.78 usec per loop （请注意，这a=[]只是设置，因此a开始为空，然后增长到100,000个元素。） 起初我以为可能是属性查找或函数调用开销，但是在末尾插入表明这可以忽略不计： > python -m timeit -n 100000 -s "a=[]" "a.insert(-1,0)" 100000 loops, …

61 python  performance 

我有这样的课： struct event_counts { uint64_t counts[MAX_COUNTERS]; event_counts() : counts{} {} // more stuff }; 通常我想默认（零）初始化counts数组，如图所示。 但是，在通过性能分析确定的选定位置，我想抑制数组初始化，因为我知道数组即将被覆盖，但是编译器不够聪明，无法弄清楚它。 创建这样的“辅助”零参数构造函数的惯用而有效的方法是什么？ 当前，我正在使用uninit_tag作为伪参数传递的标记类，如下所示： struct uninit_tag{}; struct event_counts { uint64_t counts[MAX_COUNTERS]; event_counts() : counts{} {} event_counts(uninit_tag) {} // more stuff }; 然后，像event_counts c(uninit_tag{});想抑制构造时一样，调用no-init构造函数。 我对不涉及创建哑类或以某种方式更有效的解决方案持开放态度。

41 c++  performance  constructor 

我已经编写了一些Scala代码以对集合执行按元素操作。在这里，我定义了两种执行相同任务的方法。一种方法使用zip，另一种方法使用zipped。 def ES (arr :Array[Double], arr1 :Array[Double]) :Array[Double] = arr.zip(arr1).map(x => x._1 + x._2) def ES1(arr :Array[Double], arr1 :Array[Double]) :Array[Double] = (arr,arr1).zipped.map((x,y) => x + y) 为了比较这两种方法的速度，我编写了以下代码： def fun (arr : Array[Double] , arr1 : Array[Double] , f :(Array[Double],Array[Double]) => Array[Double] , itr : Int) ={ val t0 = System.nanoTime() …

38 scala  performance  scala-collections  jmh  elementwise-operations 

因此，最初，我有以下代码： import java.util.*; public class sandbox { public static void main(String[] args) { HashSet<Integer> hashSet = new HashSet<>(); for (int i = 0; i < 100_000; i++) { hashSet.add(i); } long start = System.currentTimeMillis(); for (int i = 0; i < 100_000; i++) { for (Integer val : hashSet) { …

28 java  performance  for-loop  hashset 

我有两列制表符分隔的整数，第一列是随机整数，第二列是标识组的整数，可以通过此程序生成该整数。（generate_groups.cc） #include <cstdlib> #include <iostream> #include <ctime> int main(int argc, char* argv[]) { int num_values = atoi(argv[1]); int num_groups = atoi(argv[2]); int group_size = num_values / num_groups; int group = -1; std::srand(42); for (int i = 0; i < num_values; ++i) { if (i % group_size == 0) { ++group; …

27 c++  performance 

理论上，由于权重具有固定大小，因此预测应该是恒定的。如何在编译后恢复速度（无需删除优化器）？ 查看相关实验：https : //nbviewer.jupyter.org/github/off99555/TensorFlowExperiments/blob/master/test-prediction-speed-after-compile.ipynb?flush_cache=true

23 python  performance  tensorflow  keras  jupyter-notebook 

我试图估计我的keras模型的预测时间，并意识到一些奇怪的事情。除了正常情况下相当快外，模型偶尔还需要很长时间才能得出预测。不仅如此，这些时间还增加了模型运行的时间。我添加了一个最小的工作示例来重现该错误。 import time import numpy as np from sklearn.datasets import make_classification from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Flatten # Make a dummy classification problem X, y = make_classification() # Make a dummy model model = Sequential() model.add(Dense(10, activation='relu',name='input',input_shape=(X.shape[1],))) model.add(Dense(2, activation='softmax',name='predictions')) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(X, y, verbose=0, batch_size=20, epochs=100) …

17 python  performance  tensorflow  keras  tensorflow2.0 

我正在做一个项目，我需要所有API调用花费少于1秒的时间，但是我遇到的问题是第一次调用每条路由的速度都慢于随后的路由。 目前，首次拨打/ login的时间为3.6秒，接下来的通话为170毫秒，其他所有路由都相同。 我发现-XX:+TraceClassLoading在第一次调用时使用了该类，这些类已加载到内存中，这导致了性能问题。 但是，我没有找到一种在启动时加载所有类的简便方法，对于每个新服务，我需要在ApplicationRunner中添加一个热身调用。 是否有人可以自动加载SpringBoot应用程序的类或预热其所有路由的解决方案？

13 java  spring  performance  spring-boot 

我是工作在扩展的简单类dict，我意识到键查找和使用pickle都非常缓慢。 我认为这是我班上的一个问题，所以我做了一些琐碎的基准测试： (venv) marco@buzz:~/sources/python-frozendict/test$ python --version Python 3.9.0a0 (venv) marco@buzz:~/sources/python-frozendict/test$ sudo pyperf system tune --affinity 3 [sudo] password for marco: Tune the system configuration to run benchmarks Actions ======= CPU Frequency: Minimum frequency of CPU 3 set to the maximum frequency System state ============ CPU: use 1 logical CPUs: 3 …

13 python  python-3.x  performance  dictionary  subclass 

最近，我遇到了有关字符串串联的问题。该基准总结如下： @OutputTimeUnit(TimeUnit.NANOSECONDS) public class BrokenConcatenationBenchmark { @Benchmark public String slow(Data data) { final Class<? extends Data> clazz = data.clazz; return "class " + clazz.getName(); } @Benchmark public String fast(Data data) { final Class<? extends Data> clazz = data.clazz; final String clazzName = clazz.getName(); return "class " + clazzName; } @State(Scope.Thread) …

13 java  string  performance  compiler-optimization  string-concatenation 

考虑下面两个长度为2的代码片段： boolean isOK(int i) { for (int j = 0; j < filters.length; ++j) { if (!filters[j].isOK(i)) { return false; } } return true; } 和 boolean isOK(int i) { return filters[0].isOK(i) && filters[1].isOK(i); } 我认为，经过充分的预热后，这两块琴的性能应该相似。 我已经使用JMH微基准测试框架对此进行了检查，如此处和此处所述，并观察到第二个片段的运行速度提高了10％以上。 问题：为什么Java没有使用基本循环展开技术优化我的第一个代码段？ 特别是，我想了解以下内容： 我可以很容易地产生一个代码，为2个滤波器的情况下最佳的，仍然可以在过滤器另一个号码的情况下工作（想象一个简单的建造者）： return (filters.length) == 2 ? new FilterChain2(filters) : new FilterChain1(filters)。JITC可以这样做吗？如果不能，为什么？ …

13 java  performance  optimization  jit 

我看到React.forwardRef似乎是从react docs传递ref到子功能组件的批准方法： const FancyButton = React.forwardRef((props, ref) => ( <button ref={ref} className="FancyButton"> {props.children} </button> )); // You can now get a ref directly to the DOM button: const ref = React.createRef(); <FancyButton ref={ref}>Click me!</FancyButton>; 但是，与仅通过自定义道具相比，这样做的好处是什么？： const FancyButton = ({ innerRef }) => ( <button ref={innerRef} className="FancyButton"> {props.children} </button> )); const …

13 javascript  reactjs  performance 

我正在尝试通过某种内部方法获得尽可能多的性能。 Java代码是： List<DirectoryTaxonomyWriter> writers = Lists.newArrayList(); private final int taxos = 4; [...] @Override public int getParent(final int globalOrdinal) throws IOException { final int bin = globalOrdinal % this.taxos; final int ordinalInBin = globalOrdinal / this.taxos; return this.writers.get(bin).getParent(ordinalInBin) * this.taxos + bin; //global parent } 在我的探查器中，我看到其中有1％的CPU支出java.util.Objects.requireNonNull，但我什至没有这样说。在检查字节码时，我看到了： public getParent(I)I throws java/io/IOException …

12 java  performance  modulo  primitive-types  null-check 

关于此答案，是否存在一种快速方法来计算具有不等数量元素的组的数组的中值？ 例如： data = [1.00, 1.05, 1.30, 1.20, 1.06, 1.54, 1.33, 1.87, 1.67, ... ] index = [0, 0, 1, 1, 1, 1, 2, 3, 3, ... ] 然后，我想计算数量与每组中位数之间的差（例如，组的中位数0为1.025，则第一个结果为1.00 - 1.025 = -0.025）。因此，对于上面的数组，结果将显示为： result = [-0.025, 0.025, 0.05, -0.05, -0.19, 0.29, 0.00, 0.10, -0.10, ...] 既然np.median.reduceat还不存在，还有另一种快速的方法来实现这一目标吗？我的数组将包含数百万行，因此速度至关重要！ 可以假定索引是连续且有序的（如果不是，则很容易对其进行转换）。 性能比较的示例数据： import numpy …

12 python  performance  numpy  median  numpy-ufunc