Узнайте количество соединений с сервером кота

Я только что запустил ваш код (после исправления ряда небольших ошибок). Затем я взял несколько стопок . Люди, которые сказали, что маллок будет вашим виновником, были правы. Почти все ваше время проводится там. По сравнению с этим, остальная часть вашего кода не очень значима. Вот код:

#include <math.h>
#include <stdlib.h>
const double PI = 3.1415926535897932384626433832795;

void cos_taper(double *arr_in, double *arr_out, int npts){ 
    int i; 
//  double taper[npts];
    double* taper = (double*)malloc(sizeof(double) * npts); 
    int M;  
    M = (int)floor( ((npts - 2) / 10) + .5); 

    for (i=0; i<npts; i++){ 
        if (i<M) { 
            taper[i] = .5 * (1-cos(i * PI / (M + 1))); 
        } 
        else if (i<npts - M - 2) { 
            taper[i] = 1; 
        } 
        else if (i<npts) { 
            taper[i] = .5 * (1-cos((npts - i - 1) * PI / (M + 1))); 
        } 
        arr_out[i] = arr_in[i] * taper[i]; 
    }
    free(taper);
    return;
}

void doit(){
    int i;
    int npts = 100; 
    double *data, *cos_tapered; 

    data = (double*)malloc(sizeof(double) * npts); 
    cos_tapered = (double*)malloc(sizeof(double) * npts); 

    //fill data 
    for (i = 0; i < npts; i++) data[i] = 1;

    cos_taper(data, cos_tapered, npts); 
    free(data); 
    free(cos_tapered); 
}

int main(int argc, char* argv[]){
    int i;
    for (i = 0; i < 1000000; i++){
        doit();
    }
    return 0;
}

EDIT: Я синхронизировал вышеуказанный код, который занял 22us на моей машине (в основном в malloc ). Затем я изменил его, чтобы сделать мальоки только один раз снаружи. Это снизило время до 5 0us, которое в основном находилось в функции cos . Затем я переключился с Debug на Release build, что уронило время до 3 .7us (теперь еще больше в функции cos , очевидно). Так что если вы действительно хотите сделать это быстро, я рекомендую stackshots, чтобы выяснить, что вы в основном делаете, а затем посмотреть, если вы можете избежать этого.

Сокращенно для:

survey.map { |s| s.questions }.flatten.compact

Это метод Symbol # to _ proc . Раньше он был частью ActiveSupport Rails, но с тех пор был добавлен в синтаксис Ruby.

Что касается производительности, я написал сценарий быстрого тестирования, чтобы получить представление об эффекте производительности как в 1.8, так и в 1.9.

require 'benchmark'

many = 500
a = (1..10000).to_a

Benchmark.bm do |x|
  x.report('block once') { a.map { |n| n.to_s } }
  x.report('to_proc once') { a.map(&:to_s) }
  x.report('block many') { many.times { a.map { |n| n.to_s } } }
  x.report('to_proc many') { many.times { a.map(&:to_s) } }
end

Во-первых, прежде чем дать вам результаты - если вы уже не были уверены, что Ruby 1.9 было огромным улучшением скорости в целом, приготовьтесь к срыву.

Ruby 1.8 results:

                user        system      total       real
block once      0.020000    0.000000    0.020000    (  0.016781)
to_proc once    0.010000    0.000000    0.010000    (  0.013881)
block many      6.680000    1.100000    7.780000    (  7.780532)
to_proc many    7.370000    0.540000    7.910000    (  7.902935)

Ruby 1.9 results:

                user        system      total       real
block once      0.010000    0.000000    0.010000    (  0.011433)
to_proc once    0.000000    0.000000    0.000000    (  0.004929)
block many      4.060000    0.000000    4.060000    (  4.057013)
to_proc many    2.810000    0.000000    2.810000    (  2.810312)

First off: Wow. Рубин 1.9 быстрый. Но более актуальные выводы, которые мы здесь делаем, интересны:

• В обоих случаях, только для одного прогона, к _ proc явно быстрее. В 1.8 на многократном беге, это намного медленнее. Это указывает на то, что единственным реальным узким местом для производительности является создание всех этих объектов Proc.
• В Ruby 1,9, однако, метод to _ proc явно намного быстрее, чем блоки, независимо от того, сколько раз вы это делаете. В этом случае вы не только получаете более чистый код, но и улучшенную производительность.

В конце концов, независимо от того, какую версию вы используете, для _ proc явно недостаточно проблемы производительности, чтобы не стоит использовать - на самом деле, это иногда ускоряет ситуацию!

Наиболее надежным способом является поиск ip.addr.of.srv: port в netstat . Вот пример на базе Windows (извините, нет гуру Linux здесь;))

netstat -np tcp | find "12.34.56.78:80"

Замените 12,34,56,78 на IP, где Tomcat прослушивает, и 80 на порт, где Tomcat прослушивает.

На самом деле это не проблема программирования, поэтому я проголосовал за перенос этого вопроса в serverfault.com .