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
|
// { dg-do compile { target i?86-*-* x86_64-*-* } }
// { dg-options "-std=c++11 -O3 -march=westmere" }
template <int> struct int_ {};
template <typename> struct add_const { typedef int type; };
template <typename> struct add_reference { typedef int type; };
template <typename T> struct next { typedef typename T::next type; };
template <typename> struct size_impl;
template <typename T> struct msvc_eti_base : T {};
template <int N> struct long_ {
static const int value = N;
typedef long_<N + 1> next;
};
template <typename Sequence>
struct size : msvc_eti_base<typename size_impl<
typename Sequence::tag>::template apply<Sequence>> {};
template <typename Base> struct v_item : Base {
typedef typename next<typename Base::size>::type size;
};
template <typename = int> struct vector0 {
typedef int tag;
typedef long_<0> size;
};
template <> struct size_impl<int> {
template <typename Vector> struct apply : Vector::size {};
};
template <typename> struct vector3 : v_item<v_item<v_item<vector0<>>>> {};
template <typename> struct layout { typedef vector3<int> color_space_t; };
template <typename> struct kth_element_const_reference_type;
template <typename> struct iterator_adaptor_get_base;
template <typename, typename, int> struct homogeneous_color_base;
template <typename> struct element_const_reference_type;
template <typename Element, typename Layout>
struct homogeneous_color_base<Element, Layout, 3> {
Element _v0, _v1, _v2;
typename element_const_reference_type<homogeneous_color_base>::type
at(int_<0>) {
return _v0;
}
typename element_const_reference_type<homogeneous_color_base>::type
at(int_<1>) {
return _v1;
}
typename element_const_reference_type<homogeneous_color_base>::type
at(int_<2>) {
return _v2;
}
};
template <typename Element, typename Layout, int K1>
struct kth_element_const_reference_type<
homogeneous_color_base<Element, Layout, K1>>
: add_reference<typename add_const<Element>::type> {};
template <int K, typename E, typename L, int N>
typename add_reference<typename add_const<E>::type>::type
at_c(homogeneous_color_base<E, L, N> p1) {
return p1.at(int_<K>());
}
template <typename> class memory_based_step_iterator;
template <typename> class memory_based_2d_locator;
template <typename> class image_view;
template <typename, typename> struct pixel;
struct iterator_type_from_pixel {
typedef pixel<unsigned char, layout<vector3<int>>> *type;
};
template <typename XIterator> struct type_from_x_iterator {
typedef image_view<
memory_based_2d_locator<memory_based_step_iterator<XIterator>>> view_t;
};
template <typename>
struct element_const_reference_type
: kth_element_const_reference_type<
homogeneous_color_base<unsigned, layout<int>, 3>> {};
template <typename, typename>
struct pixel : homogeneous_color_base<unsigned char, layout<int>,
size<layout<int>::color_space_t>::value> {
};
template <typename Iterator>
struct iterator_adaptor_get_base<memory_based_step_iterator<Iterator>> {
typedef Iterator type;
};
template <typename> class memory_based_2d_locator {
public:
typedef iterator_adaptor_get_base<memory_based_step_iterator<
pixel<unsigned, layout<vector3<int>>> *>>::type x_iterator;
};
template <typename> class image_view {
public:
typedef memory_based_2d_locator<int>::x_iterator x_iterator;
x_iterator row_begin___trans_tmp_2;
x_iterator row_begin(int) { return row_begin___trans_tmp_2; }
};
template <typename, bool, typename = int> class image {
public:
typedef type_from_x_iterator<iterator_type_from_pixel::type>::view_t view_t;
image(int);
};
template <typename Pixel, bool IsPlanar, typename Alloc>
typename image<Pixel, 0>::view_t view(image<Pixel, IsPlanar, Alloc>);
template <typename Op> void measure_time(Op p1) {
for (;;)
p1();
}
template <typename, typename> struct fill_nongil_t;
template <typename T, typename P>
struct fill_nongil_t<
image_view<memory_based_2d_locator<
memory_based_step_iterator<pixel<T, layout<vector3<int>>> *>>>,
P> {
typedef image_view<memory_based_2d_locator<
memory_based_step_iterator<pixel<T, layout<vector3<int>>> *>>> View;
View _v;
P _p;
fill_nongil_t(View p1, P) : _v(p1) {}
void operator()() {
T *first = (T *)_v.row_begin(0);
T last;
while (first != &last) {
first[0] = at_c<0>(_p);
first[1] = at_c<1>(_p);
first[2] = at_c<2>(_p);
first += 3;
}
}
};
template <typename, typename> void test_fill(int) {
image<int, 0>::view_t __trans_tmp_1;
image<int, 0> im(0);
__trans_tmp_1 = view(im);
measure_time(fill_nongil_t<
image_view<memory_based_2d_locator<memory_based_step_iterator<
pixel<unsigned char, layout<vector3<int>>> *>>>,
pixel<unsigned, int>>(__trans_tmp_1, pixel<unsigned, int>()));
}
void performance_testtest_method() {
test_fill<image_view<int>, pixel<unsigned, int>>(0);
}
|
