Форум программистов, компьютерный форум, киберфорум
Наши страницы

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
IcyWind
8 / 8 / 2
Регистрация: 19.09.2011
Сообщений: 272
#1

Инлайн-функция замедляет работу - C++

11.04.2013, 16:12. Просмотров 730. Ответов 16
Метки нет (Все метки)

Здравствуйте! видимо что-то делаю неправильно...имею код. Запускаю скомпилированную программу - работает с одной скоростью. Копипастю код в инлайн функцию - скорость выполнения резко уменьшается.
если кому интересно - вот начальный код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
// Task3.cpp: определяет точку входа для консольного приложения.
//
 
#include <stdlib.h>
#include <math.h>
#include <sys/time.h>
#include <iostream>
#include <omp.h>
 
using namespace std;
 
 
int main(int argc, char **argv)
{
    int threads = atoi(argv[2]);
    int n = atoi(argv[1]);
    
 
//Задание 2
    struct timeval StartTime;
    struct timeval EndTime;
    
    double* result = new double[n*n];
    double* A = new double[n*n];
    double* B = new double[n*n];
 
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            result[i*n+j] = 0;
 
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            A[i*n+j] = i+1;
 
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            B[i*n+j] = 1.0/(j+1);
    int i,k;
    double *indres,*indA,*indB,*ind1B,*ind2B,*ind3B,*ind4B,*ind5B,*ind6B,*ind7B,*ind8B,*ind9B;
    gettimeofday(&StartTime,NULL);
 
#pragma omp parallel num_threads(threads) private(i,k,indres,indA,indB,ind1B,ind2B,ind3B,ind4B,ind5B,ind6B,ind7B,ind8B,ind9B) shared(result,A,B)
    {
#pragma omp for schedule(dynamic,25)
        for ( i = 0; i < n; i++)
    {
        indB = B;
        ind1B = B+n;
        ind2B = ind1B+n;
        ind3B = ind2B+n;
        ind4B = ind3B+n;
        ind5B = ind4B+n;
        ind6B = ind5B+n;
        ind7B = ind6B+n;
        ind8B = ind7B+n;
        ind9B = ind8B+n;
        indA = A+i*n;
        for(k =0; k < n; k+=10)
        {
            double *endres = result+(i+1)*n;
            for ( indres = result+i*n; indres < endres; indB+=5, ind1B+=5,ind2B+=5,ind3B+=5,ind4B+=5,ind5B+=5,ind6B+=5,ind7B+=5,ind8B+=5,ind9B+=5 ,indres+=5 )
            {
                indres[0] += indA[k] * indB[0];
                indres[1] += indA[k] * indB[1];
                indres[2] += indA[k] * indB[2];
                indres[3] += indA[k] * indB[3];
                indres[4] += indA[k] * indB[4];
                
                indres[0] += indA[k+1] * ind1B[0];
                indres[1] += indA[k+1] * ind1B[1];
                indres[2] += indA[k+1] * ind1B[2];
                indres[3] += indA[k+1] * ind1B[3];
                indres[4] += indA[k+1] * ind1B[4];
                
                indres[0] += indA[k+2] * ind2B[0];
                indres[1] += indA[k+2] * ind2B[1];
                indres[2] += indA[k+2] * ind2B[2];
                indres[3] += indA[k+2] * ind2B[3];
                indres[4] += indA[k+2] * ind2B[4];
                
                indres[0] += indA[k+3] * ind3B[0];
                indres[1] += indA[k+3] * ind3B[1];
                indres[2] += indA[k+3] * ind3B[2];
                indres[3] += indA[k+3] * ind3B[3];
                indres[4] += indA[k+3] * ind3B[4];
                
                indres[0] += indA[k+4] * ind4B[0];
                indres[1] += indA[k+4] * ind4B[1];
                indres[2] += indA[k+4] * ind4B[2];
                indres[3] += indA[k+4] * ind4B[3];
                indres[4] += indA[k+4] * ind4B[4];
                //
                indres[0] += indA[k+5] * ind5B[0];
                indres[1] += indA[k+5] * ind5B[1];
                indres[2] += indA[k+5] * ind5B[2];
                indres[3] += indA[k+5] * ind5B[3];
                indres[4] += indA[k+5] * ind5B[4];
                
                indres[0] += indA[k+6] * ind6B[0];
                indres[1] += indA[k+6] * ind6B[1];
                indres[2] += indA[k+6] * ind6B[2];
                indres[3] += indA[k+6] * ind6B[3];
                indres[4] += indA[k+6] * ind6B[4];
                
                indres[0] += indA[k+7] * ind7B[0];
                indres[1] += indA[k+7] * ind7B[1];
                indres[2] += indA[k+7] * ind7B[2];
                indres[3] += indA[k+7] * ind7B[3];
                indres[4] += indA[k+7] * ind7B[4];
                
                indres[0] += indA[k+8] * ind8B[0];
                indres[1] += indA[k+8] * ind8B[1];
                indres[2] += indA[k+8] * ind8B[2];
                indres[3] += indA[k+8] * ind8B[3];
                indres[4] += indA[k+8] * ind8B[4];
                
                indres[0] += indA[k+9] * ind9B[0];
                indres[1] += indA[k+9] * ind9B[1];
                indres[2] += indA[k+9] * ind9B[2];
                indres[3] += indA[k+9] * ind9B[3];
                indres[4] += indA[k+9] * ind9B[4];
            }
            indB+=9*n;
            ind1B+=9*n;
            ind2B+=9*n;
            ind3B+=9*n;
            ind4B+=9*n;
            
            ind5B+=9*n;
            ind6B+=9*n;
            ind7B+=9*n;
            ind8B+=9*n;
            ind9B+=9*n;
        }
    }
    }
    gettimeofday(&EndTime,NULL);
    double time = (EndTime.tv_sec - StartTime.tv_sec) + (EndTime.tv_usec-StartTime.tv_usec)/1000000.0;
 
    cout<<"Time - "<<fixed<<time<<" sec"<<endl;
 
    cout<<"Perfomance - "<<fixed<<2*((double)n/time)*((double)n*(double)n/1000000.0)<<" MegaFlops\n";
    cout<<fixed<<result[0];
    cout<<fixed<<"\t"<<result[n-1]<<endl;
    cout<<fixed<<result[(n-1)*n];
    cout<<fixed<<"\t"<<result[(n-1)*n+n-1]<<endl;
    cout<<"Threads count = "<<threads<<endl;
    
        delete[] result;
        delete[] A;
        delete[] B;
//Задание 2
    return 0;       
}
А это уже вставленный в функцию
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
// Task3.cpp: определяет точку входа для консольного приложения.
//
 
#include <stdlib.h>
#include <math.h>
#include <sys/time.h>
#include <iostream>
#include <omp.h>
 
using namespace std;
 
inline void Mult(double *A, double *B, double *result)
{
int i,k,n=500;
int threads = 1;
    double *indres,*indA,*indB,*ind1B,*ind2B,*ind3B,*ind4B,*ind5B,*ind6B,*ind7B,*ind8B,*ind9B;
 
#pragma omp parallel num_threads(threads) firstprivate(n) private(i,k,indres,indA,indB,ind1B,ind2B,ind3B,ind4B,ind5B,ind6B,ind7B,ind8B,ind9B) shared(result,A,B)
    {
#pragma omp for schedule(dynamic,25)
        for ( i = 0; i < n; i++)
    {
        indB = B;
        ind1B = B+n;
        ind2B = ind1B+n;
        ind3B = ind2B+n;
        ind4B = ind3B+n;
        ind5B = ind4B+n;
        ind6B = ind5B+n;
        ind7B = ind6B+n;
        ind8B = ind7B+n;
        ind9B = ind8B+n;
        indA = A+i*n;
        for(k =0; k < n; k+=10)
        {
            double *endres = result+(i+1)*n;
            for ( indres = result+i*n; indres < endres; indB+=5, ind1B+=5,ind2B+=5,ind3B+=5,ind4B+=5,ind5B+=5,ind6B+=5,ind7B+=5,ind8B+=5,ind9B+=5 ,indres+=5 )
            {
                indres[0] += indA[k] * indB[0];
                indres[1] += indA[k] * indB[1];
                indres[2] += indA[k] * indB[2];
                indres[3] += indA[k] * indB[3];
                indres[4] += indA[k] * indB[4];
                
                indres[0] += indA[k+1] * ind1B[0];
                indres[1] += indA[k+1] * ind1B[1];
                indres[2] += indA[k+1] * ind1B[2];
                indres[3] += indA[k+1] * ind1B[3];
                indres[4] += indA[k+1] * ind1B[4];
                
                indres[0] += indA[k+2] * ind2B[0];
                indres[1] += indA[k+2] * ind2B[1];
                indres[2] += indA[k+2] * ind2B[2];
                indres[3] += indA[k+2] * ind2B[3];
                indres[4] += indA[k+2] * ind2B[4];
                
                indres[0] += indA[k+3] * ind3B[0];
                indres[1] += indA[k+3] * ind3B[1];
                indres[2] += indA[k+3] * ind3B[2];
                indres[3] += indA[k+3] * ind3B[3];
                indres[4] += indA[k+3] * ind3B[4];
                
                indres[0] += indA[k+4] * ind4B[0];
                indres[1] += indA[k+4] * ind4B[1];
                indres[2] += indA[k+4] * ind4B[2];
                indres[3] += indA[k+4] * ind4B[3];
                indres[4] += indA[k+4] * ind4B[4];
                //
                indres[0] += indA[k+5] * ind5B[0];
                indres[1] += indA[k+5] * ind5B[1];
                indres[2] += indA[k+5] * ind5B[2];
                indres[3] += indA[k+5] * ind5B[3];
                indres[4] += indA[k+5] * ind5B[4];
                
                indres[0] += indA[k+6] * ind6B[0];
                indres[1] += indA[k+6] * ind6B[1];
                indres[2] += indA[k+6] * ind6B[2];
                indres[3] += indA[k+6] * ind6B[3];
                indres[4] += indA[k+6] * ind6B[4];
                
                indres[0] += indA[k+7] * ind7B[0];
                indres[1] += indA[k+7] * ind7B[1];
                indres[2] += indA[k+7] * ind7B[2];
                indres[3] += indA[k+7] * ind7B[3];
                indres[4] += indA[k+7] * ind7B[4];
                
                indres[0] += indA[k+8] * ind8B[0];
                indres[1] += indA[k+8] * ind8B[1];
                indres[2] += indA[k+8] * ind8B[2];
                indres[3] += indA[k+8] * ind8B[3];
                indres[4] += indA[k+8] * ind8B[4];
                
                indres[0] += indA[k+9] * ind9B[0];
                indres[1] += indA[k+9] * ind9B[1];
                indres[2] += indA[k+9] * ind9B[2];
                indres[3] += indA[k+9] * ind9B[3];
                indres[4] += indA[k+9] * ind9B[4];
            }
            indB+=9*n;
            ind1B+=9*n;
            ind2B+=9*n;
            ind3B+=9*n;
            ind4B+=9*n;
            
            ind5B+=9*n;
            ind6B+=9*n;
            ind7B+=9*n;
            ind8B+=9*n;
            ind9B+=9*n;
        }
    }
    }
}
 
int main(int argc, char **argv)
{
//Задание 2
    struct timeval StartTime;
    struct timeval EndTime;
    int n=500;
    
    double* result = new double[n*n];
    double* A = new double[n*n];
    double* B = new double[n*n];
 
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            result[i*n+j] = 0;
 
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            A[i*n+j] = i+1;
 
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            B[i*n+j] = 1.0/(j+1);
    
    gettimeofday(&StartTime,NULL);
    Mult(A,B,result);
    gettimeofday(&EndTime,NULL);
    double time = (EndTime.tv_sec - StartTime.tv_sec) + (EndTime.tv_usec-StartTime.tv_usec)/1000000.0;
 
    cout<<"Time - "<<fixed<<time<<" sec"<<endl;
 
    cout<<"Perfomance - "<<fixed<<2*((double)n/time)*((double)n*(double)n/1000000.0)<<" MegaFlops\n";
    cout<<fixed<<result[0];
    cout<<fixed<<"\t"<<result[n-1]<<endl;
    cout<<fixed<<result[(n-1)*n];
    cout<<fixed<<"\t"<<result[(n-1)*n+n-1]<<endl;
    
        delete[] result;
        delete[] A;
        delete[] B;
//Задание 2
    return 0;       
}
Компилятор интеловский. Если замерять время выполнения программы внутри самой функции, то производительность так же оказывается уменьшенной...что не так - понять не могу...первый вариант чуть ли не в 2 раза быстрее работает
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
11.04.2013, 16:12
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Инлайн-функция замедляет работу (C++):

Как отключить инлайн в MSVS2008? - C++
Такое дело. Я сейчас разбираюсь в дизассемблированном коде простых программ, а Visual Studio мешает мне в этом занятии. Точнее, это...

std::map в инлайн-асме - C++
Доброго времени суток Имеется MAP-массив содержащий хуки для функций Нужно получить соответствующий адрес в naked функции: ...

Реализация шаблонов класса в инлайн файле - C++
Пытался написать шаблонны MyClass.h #pragma once #define MYCLASS template &lt;typename T&gt; class MyClass { public:

Реализация шаблонов класса в инлайн файле - C++
Пытался написать шаблонный класс, реализуя как обычно объявление класса в h файле и определение элемент-функций в с++. Компилятор постоянно...

Оператор разыменования(*) значительно замедляет программу. Почему? - C++
Почему вот такой код string a, b; for (/*долго*/) { if (a &lt; b) { /* сделать что-нибудь */ } }

Программа останавливает свою работу, когда начинает выполнятся функция. Метод хорд - C++
Писал программу для нахождения приближенных корней методом хорд, но программа работает нормально только до вызова функции Hord. Ввожу...

16
ForEveR
В астрале
Эксперт С++
7983 / 4742 / 321
Регистрация: 24.06.2010
Сообщений: 10,545
Завершенные тесты: 3
11.04.2013, 16:21 #2
IcyWind, Инлайтить большие функции - это как-то грустно, не находите? К слову, совсем не факт, что функция будет заинлайнена
0
IcyWind
8 / 8 / 2
Регистрация: 19.09.2011
Сообщений: 272
11.04.2013, 17:00  [ТС] #3
Хорошо. Допустим, что она не инлайнится в функцию мейн. Тогда единственным накладным расходом будет именно вызов этой функции. Тогда всё-равно непонятно! Ведь, когда я замеряю производительность внутри самой функции - то получаю ту же картину - падение производительности примерно в 2 раза
0
Игорь с++
437 / 460 / 16
Регистрация: 26.01.2011
Сообщений: 2,032
11.04.2013, 17:29 #4
вам уже сказали , что инлайнить большие функции нельзя , почитайте про это , да и ещё компилятор видать совсем идиот если даёт это делать.Удачи
0
stima
490 / 342 / 40
Регистрация: 22.03.2011
Сообщений: 1,095
Завершенные тесты: 2
11.04.2013, 17:39 #5
Инлайнить большие функции можно, если нужно. Но есть одно ограничение inline это всего лишь пожелание к компилятору, а не строгое указание. Поэтому он оставляет за собой право встроить или нет (в данном случае нет ибо есть цикл). В вашем случае при инлайне не срабатывает #pragma omp parallel. Если вы знаете с чем работаете читайте маны, если нет, то мой вам совет не трогайте код.
2
IcyWind
8 / 8 / 2
Регистрация: 19.09.2011
Сообщений: 272
11.04.2013, 19:45  [ТС] #6
Цитата Сообщение от stima Посмотреть сообщение
Инлайнить большие функции можно, если нужно. Но есть одно ограничение inline это всего лишь пожелание к компилятору, а не строгое указание. Поэтому он оставляет за собой право встроить или нет (в данном случае нет ибо есть цикл). В вашем случае при инлайне не срабатывает #pragma omp parallel. Если вы знаете с чем работаете читайте маны, если нет, то мой вам совет не трогайте код.
c OMP я не знаком - знаю только базовые функции и директивы. Читал несколько поверхностных статей + на лекциях тоже в глубины не вдавались - слишком мало часов выделено. Код не получится "не трогать" - стоит учебная задача - вот и пытаюсь разобраться. Про инлайн я знал, что это всего-лишь пожелание.Не смотря на то, что всё обёрнуто в конструкции OMP все тесты пока проводил только на одном потоке. Меня просто поразило то, как резко падала производительность после перевода кода в функцию.
И, кстати, если в функции полностью закомментировать директивы openmp, то производительность нормализуется.
Не подскажете, как обернуть функцию в параллельную секцию? или статьи на эту тему?
и, если есть идеи как ускорить алгоритм, не используя ассемблерные вставки или другие низкоуровневые конструкции, буду очень благодарен) то, что выложил - пока предел моих знаний)
0
Игорь с++
437 / 460 / 16
Регистрация: 26.01.2011
Сообщений: 2,032
11.04.2013, 22:09 #7
Цитата Сообщение от stima Посмотреть сообщение
Инлайнить большие функции можно, если нужно
Покажи мне такого дурака который использует большие инлайн ! И что значит нужно ? Кому нужно ? Приведи реальный хоть один пример когда это обаснованно использовать , и компилятор тебя не пошлёт .

Добавлено через 1 минуту
Цитата Сообщение от Игорь с++ Посмотреть сообщение
нужно
пардон хотел написать - можно
0
stima
490 / 342 / 40
Регистрация: 22.03.2011
Сообщений: 1,095
Завершенные тесты: 2
12.04.2013, 02:37 #8
2Игорь с++ Компилятор меня не пошлет с инлайнами в любом случае, даже при -Wall и -pedantic. Что значит большие инлайны? Сколько строк? Каков их смысл? За примерами смотрите исходники webkita.

2IcyWind Ээээ батюшка да Вы невнимательно копипастите посмотрите на num_tread(), а я та замахнулся на компилятор грешить. Кстате Ваш алгоритм уже оптимизирован оочень сильно в нем учтена оптимизация на уровне инструкций, а это последняя оптимизация распаралеливания.
0
IcyWind
8 / 8 / 2
Регистрация: 19.09.2011
Сообщений: 272
12.04.2013, 02:53  [ТС] #9
Что-то не могу найти косяк копипаста...вы имеете ввиду это?
Цитата Сообщение от IcyWind Посмотреть сообщение
int threads = 1;
так это специально, чтобы просто на одном потоке проверять.
кстати, я эту всю штуку написал для использования потом в алгоритме блочного перемножения...пока тестил, нашёл ошибку в своей логике...она касается расположения блоков в массиве...
довольно трудно "выцепить" именно тот блок, который мне нужен. Для этого придумал пересчитывать индекс матрицы...при заполнении...чтобы элементы в памяти хранились последовательно по блокам. Таким образом, написанный алгоритм можно не менять нормальное ли это решение? или есть что-нибудь более интересное?
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
inline int nind(int ind)
{
    int i = ind / n;
    int j = ind % n;
    return (i/sz)*bl*sz*sz + (j/sz)*sz*sz + (i%sz)*sz + (j%sz);
}
for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            a[nind(i*n+j)] = i+1;
 
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            b[nind(i*n+j)] = 1.0/(j+1);
0
stima
490 / 342 / 40
Регистрация: 22.03.2011
Сообщений: 1,095
Завершенные тесты: 2
12.04.2013, 13:21 #10
А время вы тоже засекали на 1 потоке? Если да, то возможно повлияла синхронизация. Но чтобы точно быть знать, если интересно и есть время, дизассемблируйте обе версии посмотрите в чем разница.
0
Avazart
Эксперт С++
7247 / 5419 / 297
Регистрация: 10.12.2010
Сообщений: 24,055
Записей в блоге: 17
12.04.2013, 13:47 #11
Цитата Сообщение от IcyWind Посмотреть сообщение
Хорошо. Допустим, что она не инлайнится в функцию мейн. Тогда единственным накладным расходом будет именно вызов этой функции. Тогда всё-равно непонятно! Ведь, когда я замеряю производительность внутри самой функции - то получаю ту же картину - падение производительности примерно в 2 раза
По идее если ф-ция действительно инлайнится то должен быть прирост скорости, а не падение.
А значит дело в другом( ну или это косвенно влияет) ... то есть для чистоты эксперемента уберите распараллеливание.

Вполне возможно что inline мешает работе omp - поэтому проигрыш.
0
IcyWind
8 / 8 / 2
Регистрация: 19.09.2011
Сообщений: 272
12.04.2013, 15:06  [ТС] #12
Сначала загорелся желанием дизасемблировать...но потом понял, что это надолго...опыта то у меня нет совсем. Поэтому забил. Могу только поделиться впечатлениями. Падение производительности действительно происходит не из-за функции. Но она каким-то образом косвено влияет (в сочетании с openMP). Теперь поясню:
1.)берём код - кидаем в main() - производительность 3.7 Gflops на одном потоке, 6.8 Gflops на двух.
2.)копируем код в инлайн функцию(), передаём туда матрицы через указатели - ну как в коде. Производительность 2 Gflops на одном потоке, 4Gflops на двух.
3.)убираем слово инлайн - аналогично пункту 2
4.)убираем все упоминания об OpenMp в функции - производительность возвращается на уровень 3.7Gflops
0
stima
490 / 342 / 40
Регистрация: 22.03.2011
Сообщений: 1,095
Завершенные тесты: 2
12.04.2013, 16:06 #13
Попробуйте обьявить double *A, double *B, double *result как volatile и лучше мувните их в глобал скоп. Думаю компилятор оптимизирует их.
0
IcyWind
8 / 8 / 2
Регистрация: 19.09.2011
Сообщений: 272
13.04.2013, 08:05  [ТС] #14
Цитата Сообщение от stima Посмотреть сообщение
Попробуйте обьявить double *A, double *B, double *result как volatile и лучше мувните их в глобал скоп. Думаю компилятор оптимизирует их.
a value of type "volatile double *" cannot be used to initialize an entity of type "double *
не нравится такое компилятору. А вынос в глобал не помогает...если omp parallel вызывать в самой функции, то всё так же падает

Добавлено через 59 секунд
Видимо тогда придётся держать весь код в мейне)
0
taras atavin
3570 / 1753 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
13.04.2013, 10:09 #15
Длинно писать, что есть ручной инлайн, можно, а инлайнить большие функции средствами языка нельзя? Что за бред?

Добавлено через 7 минут
Нельзя злоупотреблять инлайном, а не инлайнить длинный функции. Функция может быть в 100 строк и инлайниться в 1000 разных мест в программе, что плохо, другая функция может занимать 5000 строк и инлайниться дважды, что примерно в десятеро лучше. Примерно потому, что важны не строки исходного текста, а байты исполняемого кода, а одно с другим связано не так однозначно, как это интуитивно представляется. Но если большая функция инлайнится один раз в цикл в 1000 шагов, то имеет только один экземпляр, это просто цикл с длинным телом, не более. Наоборот, цикл в инлайн-функции - это просто цикл. Именно ручное избыточное упоминание длинных инлайн-функций плохо. Не само их наличие и не использование в цикле, а именно многократное ручное упоминание.
0
13.04.2013, 10:09
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
13.04.2013, 10:09
Привет! Вот еще темы с ответами:

Memo замедляет работу - Delphi
Здравствуйте. var i: Integer; begin for i:=0 to 100000 do Memo1.Lines.Add(IntToStr(i)); end; При цикле, когда вывод...

Почему PFD_DOUBLEBUFFER замедляет работу? - OpenGL
Доброго времени суток. Последние несколько часов открываю для себя плюшки OpenGL, всё конечено круто, но в ходе тестирования обнаружилось,...

Замедляет ли работу приведенная конструкция - Oracle
Вопрос такой к примеру замедляет ли работу выборки такие вот конструкции к примеру ,или точно я буду выбирать запрос в запросе это...

Вирус замедляет и останавливает работу браузера - Удаление вирусов
в общем недавно началась проблема,а если точнее 2-3 дня назад,что при работе браузера опера начинают резко останавливаться станадартные...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
15
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru