Форум программистов, компьютерный форум CyberForum.ru

Падение производительности на gcc - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Файловый и консольный ввод и вывод http://www.cyberforum.ru/cpp-beginners/thread454794.html
нужно написать программы одна чтобы вводила функцию консольно, а другая файлово
C++ Работа с allocator (управление памятью) Нормальной инфы на русском языке я так и не нашел в инете( про него читал в книге Программирование принципы и практика С++ Страуструп, но там так и реализацию функции для своего аллокатора , только дали интерфейс класс ), понял что есть 4 основные функции temlpate<class T> class allocator { // ... T* allocate(int n); void deallocate(T* p, int n); void construct(T *p,... http://www.cyberforum.ru/cpp-beginners/thread454785.html
Исчезает всё нарисованное на gdi+ C++
Доброго времени суток! Пишу подобие своего gui на gdi+.. Всё бы хорошо, но через некоторое время (около минуты), исчезает всё нарисованное.. и никакой Invalidate не помогает(( Что же делать?? Может где-то я не освобождаю ресурсы?? другого объяснения найти не могу( После каждого движения мышкой проверяю положения курсора, и если он попал в кнопку, то отрисовываю картинку с помощью...
Заполнение списка с возможностью перестановки его строк C++
Как написать программу которая string загоняет в список, чтоб потом можно было переставлять строки и.т.п?
C++ Класс с динамическим массивом http://www.cyberforum.ru/cpp-beginners/thread454744.html
доброго времени суток! помогите мне немножко: создать клас vector для сохранения массиву, розмеры от 10 до 10к, память виделите динамчно. забаспечте индексацыю елементов.
C++ Найти объединение и симметрическая разность Пожалуйста, помогите написать программу, находящую объединение и симметрическую разность элементов двух множеств подробнее

Показать сообщение отдельно
Питекантроп
246 / 140 / 6
Регистрация: 14.06.2010
Сообщений: 340
01.03.2012, 17:27  [ТС]
Цитата Сообщение от fasked Посмотреть сообщение
Версия gcc?
с коллекции mingw 4.6.1

Добавлено через 7 минут
если интересно, то попробуйте сами:
main.cpp
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
#include "stdio.h"
#include  "time.h"
#include  "stdlib.h"
#include "complex.h"
 
#include  "math.h"
#include "string.h"
 
//g++ -O3 -msse -msse3 -msse2 main.cpp
#include "pmmintrin.h"
#include "emmintrin.h"
#include "xmmintrin.h"
//__m128d x128 = {
 
int main()
{
 
    dComplex C(1,2), C1(2,4), C2(-1,-1), D(10,0);
    int tm = clock();
    for (int i = 0; i < 1000000000; ++i)
    {
        C1.Re = i & 15;     // меняем входной аргумент, чтоб компилер не пропускал цикл
        C = C1 * C2 + (C2 - C1) * C1;
    }
    tm = clock() - tm;
    printf("time: %f\n",tm * 0.001);
 
 
    printf("%f %f\n",C.Re,C.Im);
 
    return 0;
}
complex.h:
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
#ifndef COMPLEX
#define COMPLEX
//g++ -O3 -march=k8 -mfpmath=sse -msse3 -msse2 main.cpp complex.cpp
//g++ -O3 -msse -msse3 -msse2 main.cpp
#include "stdlib.h"
#include "math.h"
#include "stdlib.h"
#include "math.h"
 
#include "pmmintrin.h"
#include "emmintrin.h"
#include "xmmintrin.h"
 
 
static __m128d __m128d_1_1 = {-1.0,-1.0},
        __m128d1_1 = {1.0,-1.0};
//__declspec(align(16)) 
struct dComplex
{
        union compl_value
        {
            __m128d value;
            struct re_im_ { double re, im; } re_im;
        } value_un;
#define Re value_un.re_im.re
#define Im value_un.re_im.im
#define Value value_un.value
#define to_xmm(v) *((__m128d*)(&(v)))
#define to_compl(v) *((dComplex*)(&(v)))
        dComplex()
        { }
        ~dComplex()
        { }
        dComplex(double re, double im);
        dComplex(const __m128d & val_xmm);
        dComplex(const dComplex & orig);
        dComplex& operator = (const dComplex & val);
 
        double Module();
        
        double Argument();
        
        dComplex operator + (const dComplex & val);
        dComplex operator - ();
        dComplex operator - (const dComplex & val);
        
 
        dComplex operator * (const dComplex & val);
        
        dComplex operator / (const dComplex & val);
        
        dComplex  operator ^ (int ext);
        
        dComplex  operator ^ (const dComplex & val);
        
        dComplex& operator = (double val);
        dComplex& operator = (const double values[]);
        //dComplex& operator = (const expComplex & exp_compl);
 
};
 
 
        dComplex::dComplex(double re, double im)
        { 
            Re = re;
            Im = im;
        }
        dComplex::dComplex(const __m128d & val_xmm)
        { 
            Value = val_xmm;
        }
        dComplex::dComplex(const dComplex & orig)
        { 
            Value = orig.Value;
        }
        dComplex& dComplex::operator = (const dComplex & val)
        {
            return to_compl(Value = val.Value);
        }
 
        double dComplex::Module()
        {
            compl_value x_un;
            x_un.value = _mm_sub_pd(Value, Value);
            return sqrt(x_un.re_im.re + x_un.re_im.im);
        }
        
        double dComplex::Argument()
        {
            return atan2(Im, Re);
        }
        
        dComplex dComplex::operator + (const dComplex & val)
        {
            return dComplex(_mm_add_pd(Value,val.Value));
        }
        dComplex dComplex::operator - ()
        {
            return dComplex(_mm_mul_pd(Value,__m128d_1_1));
        }
        dComplex dComplex::operator - (const dComplex & val)
        {
            return dComplex(_mm_sub_pd(Value,to_xmm(val)));
        }
        
 
        dComplex dComplex::operator * (const dComplex & val)
        {   
        //  return dComplex(Re * val.Re - Im * val.Im, Re * val.Im + Im * val.Re);
            return dComplex(_mm_addsub_pd(
                _mm_mul_pd(Value, _mm_movedup_pd(val.Value)),
                _mm_mul_pd(
                    _mm_shuffle_pd(Value ,Value, 1),
                    _mm_shuffle_pd(val.Value, val.Value, 3)
                    )
                ));
        }
        
        dComplex dComplex::operator / (const dComplex & val)
        {   
            __m128d x = _mm_mul_pd(val.Value,val.Value),
                r = _mm_shuffle_pd(Value ,Value, 1),
                val_inv = _mm_mul_pd(val.Value, __m128d1_1);
 
            return dComplex(_mm_div_pd(
                _mm_addsub_pd(
                    _mm_mul_pd(Value,_mm_movedup_pd(val_inv)),//_mm_shuffle_pd(val.Value, val.Value, 0)),
                    _mm_mul_pd(
                        r,
                        _mm_shuffle_pd(val_inv, val_inv, 3)
                    )),
                _mm_hadd_pd(x,x)
                ));
        }
        
        dComplex  dComplex::operator ^ (int ext)
        {
            int ex = abs(ext);
            dComplex ret = (ex & 1) ? *this : dComplex(1,0), 
                p = *this;
            while (ex >>= 1)
            {
                p = p * p;
                if (ex & 1) ret = ret * p;
            }
            return ext >= 0 ? ret : dComplex(1,0) / ret;
        }
        
        dComplex  dComplex::operator ^ (const dComplex & val)
        {
            if (val.Im == 0 && val.Re == (int)val.Re)
                return operator ^ ((int)val.Re);
            dComplex EXT(dComplex(
                        0.5 * log(Im * Im + Re * Re),
                        atan2(Im, Re)
                        ) * val);
            return _mm_mul_pd(
                        _mm_movedup_pd(_mm_set_sd(exp(EXT.Re))),
                        _mm_set_pd(sin(EXT.Im),cos(EXT.Im))
                        );
        }
        
        dComplex& dComplex::operator = (double val)
        {
            Re = val;
            Im = 0;
            return *this;
        }
        dComplex& dComplex::operator = (const double values[])
        {
            Re = values[0];
            Im = values[1];
            return *this;
        }
#endif
компиляция: g++ -O3 -msse -msse2 -msse3 main.cpp complex.h

Затем скопируйте реализацию вместе с инклудами в complex.cpp, дописав #include "complex.h" и откомпилируйте
g++ -O3 -msse -msse2 -msse3 main.cpp complex.cpp

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