მასივების სტრუქტურა სტრუქტურების მასივის წინააღმდეგ

Structure of Arrays vs Array of Structures

        ამ პოსტში ჩვენ განვიხილავთ მონაცემთა ორგანიზების 3 მექანიზმს და მათ შორის განსხვავებას:

1. სტრუქტურების მასივს(Array of Structures).
2. მასივების სტრუქტურას(Structure of Arrays).
3. მასივების სტრუქტურების მასივი(Array of Structure of Arrays)

        განვიხილოთ მონაცემების პროცესორზე გადაცემის, კეშირების და დამუშავების მექანიზმი, რომელიც დეველოპერისგან მთლიანად დამალულია. პროცესორში ინსტრუქციების და მონაცემების გადატანა ხდება პერიოდულად და იმისთვის, რომ ყოველ ახალ ინსტრუქციაზე და მონაცემზე არ მოუწიოს წინ და უკან სიარული პროცესორში აქვს შესაბამისი კეშები(ინსტრუქციების და მონაცემების), ამიტომ პროგრამის მიმდინარეობის პროცესში, როდესაც ხდება მონაცემზე მიმართვა ხდება ამ მონაცემის მცირე მიდამოს გადატანა კეშში იმ იმედით, რომ შემდეგ ინსტრუქციებზე ეს მონაცემები შეიძლება დასჭირდეს. სწორედ ამ მიზეზის გამო, მონაცემების არასწორი ორგანიზების შემთხვევაში, როდესაც საჭირო ინფორმაციები გაბნეული არიან მეხსიერების სხვადასხვა ბლოკებში ვერ ხერხდება მონაცემების კეშის ეფექტური გამოყენება, რაც საბოლოოდ წარმადობაზე მკვეთრად აისახება.

სურათი ვიზუალურად ასახავს AoS-დან SoA-ში მონაცემების ტრანსფორმაციას.

მოვიყვანოთ სტრუქტურების მასივის მაგალითი:
//მონაცემთა სტრუქტურა რომელიც შედგება 4 float ელემენტისგან
struct color {
float r;
float g;
float b;
float a;
};

//მონაცემთა სტრუქტურა რომელიც ინახავს სტრუქტურების მასივს
struct pixelsAoS {
pixelsAoS(unsigned long int count) {
  size = count;
  rgba = new color[count];
}

~pixelsAoS() {
  delete[] rgba;
}

color* rgba;
unsigned long int size;
};
         ასეთ შემთხვევაში მონაცემები მეხსიერებაში განლაგდებიან შემდეგი თანმიმდევრობით: r1, g1, b1, a1, r2, g2, b2, a2, r3, g3, b3, a3, ..., rn, gn, bn, an. ახლა განვიხილოთ მასივების სტრუქტურის შემთხვევა. მოვიყვანოთ პროგრამული მაგალითი:
struct pixelsSoA {
pixelsSoA(unsigned long int count) {
  size = count;
  r = new float[count];
  g = new float[count];
  b = new float[count];
  a = new float[count];
}

~pixelsSoA() {
  delete[] r;
  delete[] g;
  delete[] b;
  delete[] a;
}

float* r;
float* g;
float* b;
float* a;
unsigned long int size;
};
        მასივების სტრუქტურის შემთხვევაში მონაცემები მეხსიერებაში გადალაგდებიან შემდეგნაირად: r1, r2, r3, r4, ...rn, g1, g2, g3, g4, ..., gn, b1, b2, b3, b4, ..., bn, a1, a2, a3, a4, ...an. მონაცემთა ჩაწერის ეს მეთოდი უფრო ეფექტურია კეშირების დროს, რადგან ასეთ ჩანაწერში ერთი და იგივე ველები მეხსიერებაში მიმდევრობით ხვდებიან და შესაბამისად კეშირებისას ნაკლებია იმის შანსი, რომ კეშში წამოღებულ მეხსიერების ნაწილს არასაჭირო ინფორმაცია წამოყვება. თუმცა ამ შემთხვევაში გასათვალისწინებელია კიდევ ერთი მნიშვნელოვანი რამ: რადგან ჩვენ პროცესორში გვაქვს ფიქსირებული ზომის კეში(რეალურად არსებობს რამოდენიმე დონის კეში სანამ ჩვენი მეხსიერება მიაღწევს პროცესორამდე), თუ ჩვენ გვექნება დიდი მასივები სტრუქტურაში და ისინი არ ჩაეტევიან კეშში, მაშინ კეშის მოქმედების ეფექტურობა ისევ დაეცემა. სწორედ ამიტომ გახდა მონაცემების კიდევ უფრო მოსახერხებელი ფორმით ჩაწერა რომელსაც ქვია მასივების სტრუქტურების მასივი. ასეთი ჩანაწერი საშუალებას გვაძლევს შევქმნათ მასივების სტრუქტურები რომელთაც ექნება სასურველი ზომა(ისეთი რომ კესში მთლიანად მოთავსდეს) და ამ ტიპის სტრუქტურის ელემენტები შევინახოთ მასივში. ასთი ტიპის ტრანსფორმაცია ზრდის არა მხოლოდ კეშის უშაობის ეფექტურობას არამედ ასევე მოსახერხებელია SIMD გამოთვლების დროს, რაც საბოლოო ჯამში ძალიან მკვეთრად მოქმედებს წარმადობაზე.