پردازنده برداری

یک پَردازنده بُرداری، یا آرایه‌پرداز، رایانهٔ خاصی است با چند پردازنده برای پردازش موازی تعداد زیادی از آرایه‌ها.
آرایه‌پرداز در واقع یک واحد پردازش مرکزی (CPU) می‌باشد که یک مجموعه دستورالعمل‌هایی را اجرا می‌کند که روی آرایه تک بعدی از داده، که همان بردار است، عمل می‌کند. این درست مقابل پردازنده‌های عددی قرار می‌گیرد که دستورالعمل‌های آن صرفاً روی یک تکه داده عمل می‌کند. اکثر پردازنده‌ها، پردازنده‌های عددی می‌باشند.
پردازنده‌های برداری در دهه ۱۹۷۰ مورد بحث واقع شدند و پایه و اساس اکثر ابررایانه‌های دهه ۱۹۸۰ تا ۱۹۹۰ را تشکیل دادند. پیشرفتهای پردازنده‌های عددی، مخصوصاً ریزپردازنده‌ها، باعث کاهش به کار گیری پردازنه‌های برداری سنتی در ابررایانه‌ها و همچنین کاهش استفاده از تکنیک‌های پردازش برداری در پردازنده‌ها در اوایل دهه ۱۹۹۰ شد. امروزه اکثر پردازنده‌ها از یک معماری استفاده می‌کنند که در آن دستورالعمل‌هایی برای پردازش برداری روی چندین تکه داده، را به‌طور برجسته نشان می‌دهد. این دستورالعمل‌ها را
SIMD
(تک دستور، چند داده) می‌شناسند. از مثال‌های مشهود اینگونه دستورالعمل‌ها می‌توان به MMX,
SSE و
AltiVec
اشاره کرد. نمونه‌هایی از استفاده از تکنیک پردازش برداری را می‌توان در کنسول‌های بازی و شتاب دهنده گرافیکی نیز پیدا کرد. در سال ۲۰۰۰، IBM، توشیبا و سونی با همکاری هم موفق به تولید یک پردازنده سلولی (نوعی ریزپردازنده) شدند، این پردازنه سلولی شامل یک پردازنده عددی و هشت پردازنده برداری بود که در پلی استیشن ۳ مورد استفاده قرار گرفت.
در برخی از طراحی‌های پردازنده‌ها، دستورالعمل‌های چندگانه روی چندین تکه داده عمل می‌کنند که آن‌ها را به عنوان MIMD (چند دستوره، چند داده) می‌شناسیم. اینگونه طراحی‌ها مختص کاربردهای ویژه هستند و به‌طور عادی برای استفاده‌های متداول کاربرد ندارند.

تاریخچه

پردازش برداری اولین بار در اوایل دهه ۱۹۶۰ توسط وستینگهاوس، در پروژه Solomon مورد توجه قرار گرفت و توسعه یافت. هدف این پروژه افزایش چشمگیر سرعت محاسبات ریاضی، با استفاده همزمان از تعداد زیادی عملیات ساده ریاضی، زیر نظر یک پردازنده بود. به این صورت که پردازنده در هر کلاک یک سیگنال مشترکی را برای تمامی واحدهای محاسبه و منطق (ALUها) می‌فرستاد. در حالی که هر یک از این واحدهای محاسبه ورودی‌های مجزایی داشتند، یک کار مشترک روی آن ورودی‌ها انجام می‌دادند. این روش به ماشین‌های Solomon این قابلیت را می‌داد که یک الگوریتم را روی انبوهی از داده‌ها (که از آرایه‌ها تغذیه می‌شدند) اجرا نماید.

در سال ۱۹۶۲، وستینگهاوس پروژه را لغو کرد ولی دوباره در دانشگاه ایلینوی تحت عنوان ILLIAC IV از سر گرفته شد. در طراحی ابتدایی آن، این ماشین به ۲۵۶ واحد محاسبه و منطق مجهز بود، درحالی که وقتی در سال ۱۹۷۲ عرضه شد تنها ۶۴ واحد محاسبه و منطق داشت و فقط می‌توانست ۱۰۰ تا ۱۵۰ میلیون فلاپس کار کند. برای کار با اطلاعات فشرده و حجیم، مانند دینامیک محاسباتی سیالات، همین ماشین معیوب (به دلیل اینکه نتوانستند تعداد ۲۵۶ واحد محاسبه و منطق ایجاد کنند) سریعترین ماشین دنیا بود.

تکنیک پردازش برداری تقریباً در تمام طراحی‌های پردازنده‌های مدرن وجود دارند، اگرچه معمولاً با نام SIMD می‌شناسند. در اینگونه پردازنده‌ها، واحد پردازش برداری در کنار واحد پردازنده عددی کار می‌کند و برنامه‌هایی با آن بخش کار می‌کنند که واقعاً می‌دانند که این واحد حضور دارد.

جزئیات

بیشتر پردازنده‌ها دستورالعملی دارند که بیان می‌کند «A را با B جمع کن و درون C بریز». مقادیر A, B و C (حداقل در تئوری) به ندرت می‌تواند داخل دستورالعمل باشند (چه به صورت صریح، چه رجیستر). در واقع داده به ندرت به‌طور خام فرستاده می‌شود، بلکه به صورت اشاره‌ای به آدرس حافظه که داده داخل آن است، می‌باشد. رمزگشایی این نشانی و دریافت داده از حافظه، خود زمان بر است. با افزایش سرعت پردازنده‌ها، این تأخیر حافظه تبدیل به مانعی بزرگ برای عملکرد سریع پردازنده محسوب می‌شود.

خط لوله

برای کاهش زمان تأخیر، اغلب پردازنده‌های امروزی از فن خط لوله استفاده می‌کنند. در این تکنیک دستورالعمل‌ها از چندین بخش عبور می‌کند تا نوبتش برای اجرا فرارسد. اولین بخش، آدرس را خوانده و کدگشایی می‌کند، بخش بعد مقادیر آدرسها را از حافظه می‌گیرد و بعدی کار محاسبه و اجرا را انجام می‌دهد. در تکنیک خط لوله، رمز کار در این است که شروع کدگشایی دستورالعمل بعدی، باید حتی قبل از خروج دستورالعمل قبلی از پردازنده صورت گیرد؛ در نتیجه واحد کدگشایی آدرس همواره مشغول به کار می‌باشد. هر دستورالعمل برای اجرای کامل به همان زمان قبلی (بدون خط لوله) نیاز دارد. زمانی که آن را تأخیر می‌نامیم؛ ولی پردازنده با خط لوله می‌تواند دسته‌ای از دستورالعملها را خیلی سریعتر انجام دهد.

پردازنده برداری

پردازنده برداری یک قدم فراتر برمی‌دارد و بجای ایجاد خط لوله برای دستورالعمل‌ها، داده‌ها را نیز خط لوله می‌کند. دستورالعملهایی هستند که بجای اینکه بگویند «A را با B جمع کن»، می‌گوید «تمامی اعداد از اینجا تا آنجا را با تمامی اعداد از اینجا تا آنجا جمع کن». و بجای اینکه دستورالعمل‌ها را پشت سر هم رمزگشایی و داده‌های مربوط به آن‌ها را از حافظه دریافت کند، یک دستورالعمل را از حافظه می‌خواند و با فرض اینکه می‌داند که آدرس بعدی یکی بیشتر از آدرس فعلی است، دستورالعمل بعدی را رمزگشایی می‌کند. این عمل صرفه جویی چشمگیری در زمان رمزگشایی می‌کند.
برای نشان دادن اینکه چه تفاوتی می‌کند، فرض کنید می‌خواهیم دو آرایه ۱۰ تایی از اعداد را با هم جمع کنیم. در حالت عادی نیاز به یک حلقه داریم که هر بار یک زوج از این دو آرایه را انتخاب می‌کند و سپس آن‌ها را با هم جمع می‌کند:
 execute this loop 10 times
 read the next instruction and decode it
 fetch this number
 fetch that number
 add them
 put the result here
 end loop
در حالی که در پردازش برداری اینگونه خواهد بود:
 read instruction and decode it
 fetch these 10 numbers
 fetch those 10 numbers
 add them
 put the results here
در پردازش برداری، اول اینکه فقط دو انتقال آدرس از پردازنده به حافظه داریم، همچنین در این حالت بجای اینکه ۱۰ مرتبه یک دستورالعمل را کدگشایی کند تنها یک بار این کار را انجام می‌دهد. همچنین کد مورد استفاده در پردازش برداری کوتاه‌تر است که این خود سبب کاهش حافظه مورد نیاز برای دستورالعمل‌های آن می‌باشد.
بررسی وابستگی بین این اعداد لازم نیست چون دستورالعمل برداری، چندین عمل غیر وابسته را معین می‌کند. این خود منطق کنترل را ساده می‌کند.
مسئله زمانی جالب تر می‌شود که بتوان چند عمل را روی چند داده انجام داد. کد زیر را در نظر بگیرید که در آن می‌خواهیم دو گروه عدد را با هم جمع کنیم و سپس با گروه سوم ضرب کنیم. در این کد عمل دریافت دستورالعمل فقط یک بار انجام می‌شود (بر خلاف حالت عادی که ۲*۱۰=۲۰) و این دو عمل فقط در یک دستورالعمل انجام می‌پذیرد:
 read instruction and decode it
 fetch these 10 numbers
 fetch those 10 numbers
 fetch another 10 numbers
 add and multiply them
 put the results here
عملیات ریاضی بالا خیلی سریعتر انجام خواهند شد چرا که دیگر تأخیر در دریافت و کدگشایی دستورالعمل بعدی را نداریم (فقط یک دستورالعمل داریم).

جنبه منفی

باید توجه داشت که تمام مسائل را نمی‌توان با استفاده از این روش بهبود داد. پیاده‌سازی این دستورالعمل‌ها در پردازنده خود پیچیدگی زیادی را بر هسته پردازنده تحمیل می‌کند. این پیچیدگی‌ها معمولاً سبب می‌شوند که دستورالعمل‌های دیگر دیرتر اجرا شوند. به عنوان مثال زمانی که بخواهیم فقط دو عدد تنها را با هم جمع کنیم. همچنین دستورالعمل‌های پیچیده سبب کندی قسمت رمزگشایی و پیچیدگی بیشتر آن خواهد شد، که این خود باعث کندی اجرای دستورات عادی می‌شود.

جنبه مثبت و کاربرد

در حقیقت، پردازش برداری برای انجام عملیات روی انبوهی از داده‌ها بهترین کارایی را دارند. برای همین است که این پردازنده‌ها اصولاً در ابر رایانه‌ها استفاده می‌شوند. این ابر رایانه‌ها عموماً برای پیش‌بینی وضعیت هوا و آزمایشگاه‌های فیزیک استفاده می‌شوند که انبوهی از داده را به چالش می‌گیرد.

مثال دنیای واقعی: دستورالعملهای برداری در معماری x86

کد زیر مثال حقیقی معماری x86 با دستورالعمل‌های برداری می‌باشد. در اینجا از دو آرایه اعداد اعشاری استفاده می‌کند.
//SSE simd function for vectorized multiplication of 2 arrays with single-precision floatingpoint numbers//1st param pointer on source/destination array, 2nd param 2. source array, 3rd param number of floats per array
 void mul_asm(float* out, float* in, unsigned int leng)
 {    unsigned int count, rest;

      //compute if array is big enough for vector operation
      rest  = (leng*4)%16;
      count = (leng*4)-rest;

     // vectorized part; 4 floats per loop iteration
      if (count>0){
      __asm __volatile__  (".intel_syntax noprefix\n\t"
      "loop:                 \n\t"
      "movups xmm0, [ebx+ecx] ;loads 4 floats in first register (xmm0)\n\t"
      "movups xmm1, [eax+ecx] ;loads 4 floats in second register (xmm1)\n\t"
      "mulps xmm0,xmm1       ;multiplies both vector registers\n\t"
      "movups [eax+ecx],xmm0 ;write back the result to memory\n\t"
      "sub ecx,16            ;increase address pointer by 4 floats\n\t"
      "jnz loop              \n\t"
      ".att_syntax prefix    \n\t"
        : : "a" (out), "b" (in), "c"(count), "d"(rest): "xmm0","xmm1");
      }

      // scalar part; 1 float per loop iteration
      if (rest!=0)
      {
       __asm __volatile__  (".intel_syntax noprefix\n\t"
      "add eax,ecx           \n\t"
      "add ebx,ecx           \n\t"

      "rest:                 \n\t"
      "movss xmm0, [ebx+edx]  ;load 1 float in first register (xmm0)\n\t"
      "movss xmm1, [eax+edx]  ;load 1 float in second register (xmm1)\n\t"
      "mulss xmm0,xmm1       ;multiplies both scalar parts of registers\n\t"
      "movss [eax+edx],xmm0  ;write back the result\n\t"
      "sub edx,4             \n\t"
      "jnz rest              \n\t"
      ".att_syntax prefix    \n\t"
        : : "a" (out), "b" (in), "c"(count), "d"(rest): "xmm0","xmm1");
      }
      return;
 }