Discussion :

[nasboy3d]

Bonjour à vous développeurs qui comme moi n'ont pas de vacances....
J'aimerais optimiser mon raytracing..Pour cela je veux utiliser les intinsics SEE2
de MSVC....Mais j'arrive pas à faire un vector<__m128>......J'ai toujours une erreur à l'exécution.....J'ai cherché partout sur internet mais rien de concret....
Enfin maintenant je sais que cela doit toujours etre aligné sur 16 octets et qu'il faut utiliser _aligned_malloc(size,alignment)......mais ça ne me dit pas pkoi ça plante avec un vector<__m128>
Donc si quelqu'un sait comment faire, j'attend devant mon écran loin des plages ensoleillées.....
Merci

[screetch]

un vector<__m128> n'offre aucune garantie quant à l'alignement (enfin je ment, ils offrent une garantie d'alignement spécifique a l'OS et l'implémentation qui est en général de 4 octets)

les vector prennent en second argument de template un type Allocator qu'ils utilisent pour allouer la mémoire: tu pourrais créer ton type allocator pour allouer avec un alignement de 16.

[nasboy3d]

merci screetch...je vais essayer ça et je vous tiens au courant....

[nasboy3d]

T'as raison screetch il faudrait implémenter une classe allocator....j'ai vu le modèle de l'allocator standard de la stl....... Mais vu tout le taf que j'ai...ça m'aidera beaucoup si quelqu'un l'a déjà fait et me file le code........
Sinon je le coderai moi-meme dans 48 heures...
Merci d'avance

[nasboy3d]

Je me répond......J'ai trouvé un code tout fait qui marche de tonnerre....
Donc pour ceux qui ont eu le meme pb que moi.... voilà la classe allocator version custom bien adapté au vector :<__m128, aligned_allocator<__m128> >

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
template <class T , int Alignment=16>
  class aligned_allocator 
  {
     public:
 
       typedef size_t    size_type;
       typedef ptrdiff_t difference_type;
       typedef T*        pointer;
       typedef const T*  const_pointer;
       typedef T&        reference;
       typedef const T&  const_reference;
       typedef T         value_type;
 
 
       template <class U>
       struct rebind
	   {
           typedef aligned_allocator<U> other;
       };
 
 
       pointer address (reference value) const 
	   {
           return &value;
       };
 
       const_pointer address (const_reference value) const 
	   {
           return &value;
       };
 
 
       aligned_allocator() throw() 
	   {
       };
 
	   aligned_allocator(const aligned_allocator&) throw() 
	   {
       };
 
	   template <class U>
         aligned_allocator (const aligned_allocator<U>&) throw() 
	   {
       };
 
       ~aligned_allocator() throw() 
	   {
       };
 
      //max capacity
       size_type max_size () const throw() 
	   {
		   return 268435455;
       };
 
 
       pointer allocate (size_type num, const_pointer *hint = 0) 
	   {
 
           return (pointer) _aligned_malloc( num*sizeof(T),Alignment);
       };
 
 
       void construct (pointer p, const T& value) 
	   {
 
          // memcpy( p, &value, sizeof T );
		   *p=value;
		 //  new ( (void *) p ) T ( value );
       };
 
 
       void destroy (pointer p) 
	   {
 
           p->~T();
       };
 
 
       void deallocate (pointer p, size_type num) 
	   {
 
           _aligned_free( p );
       };
 };

Voilà à bientot amis développeurs