نمای کلی RenderScript

RenderScript چارچوبی برای اجرای وظایف محاسباتی فشرده با عملکرد بالا در اندروید است. RenderScript اساساً برای استفاده با محاسبات موازی داده طراحی شده است، اگرچه بارهای کاری سریال نیز می توانند مفید باشند. زمان اجرا RenderScript کار را در بین پردازنده‌های موجود در یک دستگاه، مانند پردازنده‌های چند هسته‌ای و پردازنده‌های گرافیکی، موازی می‌کند. این به شما امکان می دهد به جای زمان بندی کار، بر بیان الگوریتم ها تمرکز کنید. RenderScript به ویژه برای برنامه هایی که پردازش تصویر، عکاسی محاسباتی یا بینایی کامپیوتر را انجام می دهند مفید است.

برای شروع با RenderScript، دو مفهوم اصلی وجود دارد که باید درک کنید:

• خود این زبان یک زبان مشتق شده از C99 برای نوشتن کدهای محاسباتی با کارایی بالا است. نوشتن یک هسته RenderScript نحوه استفاده از آن برای نوشتن هسته های محاسباتی را توضیح می دهد.
• کنترل API برای مدیریت طول عمر منابع RenderScript و کنترل اجرای کرنل استفاده می شود. این در سه زبان مختلف موجود است: جاوا، C++ در Android NDK، و خود زبان هسته مشتق شده از C99. با استفاده از RenderScript از Java Code و Single-Source RenderScript به ترتیب گزینه های اول و سوم را شرح می دهند.

نوشتن یک هسته RenderScript

یک هسته RenderScript معمولاً در یک فایل .rs در فهرست <project_root>/src/rs قرار دارد. هر فایل .rs یک اسکریپت نامیده می شود. هر اسکریپت حاوی مجموعه ای از هسته ها، توابع و متغیرهای خاص خود است. یک اسکریپت می تواند شامل موارد زیر باشد:

• یک بیانیه پراگما ( #pragma version(1) ) که نسخه زبان هسته RenderScript استفاده شده در این اسکریپت را اعلام می کند. در حال حاضر، 1 تنها مقدار معتبر است.
• یک اعلان پراگما ( #pragma rs java_package_name(com.example.app) ) که نام بسته کلاس‌های جاوا منعکس شده از این اسکریپت را اعلام می‌کند. توجه داشته باشید که فایل .rs شما باید بخشی از بسته برنامه شما باشد و نه در پروژه کتابخانه.
• توابع غیر قابل فراخوانی صفر یا بیشتر یک تابع فراخوانی یک تابع RenderScript تک رشته ای است که می توانید از کد جاوا با آرگومان های دلخواه فراخوانی کنید. اینها اغلب برای راه اندازی اولیه یا محاسبات سریال در یک خط لوله پردازش بزرگتر مفید هستند.

• صفر یا بیشتر جهانی های اسکریپت . یک اسکریپت جهانی شبیه به یک متغیر سراسری در C است. می‌توانید از کد جاوا به جهانی‌های اسکریپت دسترسی داشته باشید، و اغلب برای ارسال پارامتر به هسته‌های RenderScript استفاده می‌شوند. جهانی های اسکریپت در اینجا با جزئیات بیشتری توضیح داده شده است.

• هسته محاسباتی صفر یا بیشتر هسته محاسباتی یک تابع یا مجموعه ای از توابع است که می توانید زمان اجرا RenderScript را به صورت موازی در مجموعه ای از داده ها اجرا کنید. دو نوع هسته محاسباتی وجود دارد: هسته‌های نقشه‌برداری (که به آن هسته‌های پیشرو نیز گفته می‌شود) و هسته‌های کاهشی .

  هسته نقشه برداری یک تابع موازی است که بر روی مجموعه ای از Allocations با ابعاد مشابه عمل می کند. به طور پیش فرض، برای هر مختصات در آن ابعاد یک بار اجرا می شود. معمولاً (اما نه به طور انحصاری) برای تبدیل مجموعه ای از Allocations ورودی به Allocation خروجی یک Element در یک زمان استفاده می شود.

  • در اینجا یک نمونه از یک هسته نقشه برداری ساده آورده شده است:

    uchar4 RS_KERNEL invert(uchar4 in, uint32_t x, uint32_t y) {
      uchar4 out = in;
      out.r = 255 - in.r;
      out.g = 255 - in.g;
      out.b = 255 - in.b;
      return out;
    }

    از بسیاری جهات، این با یک تابع استاندارد C یکسان است. ویژگی RS_KERNEL اعمال شده بر روی نمونه اولیه تابع مشخص می کند که تابع به جای یک تابع فراخوانی، یک هسته نقشه برداری RenderScript است. آرگومان in به طور خودکار بر اساس Allocation ورودی ارسال شده به راه اندازی هسته پر می شود. آرگومان های x و y در زیر مورد بحث قرار می گیرند. مقدار بازگشتی از هسته به طور خودکار در محل مناسب در Allocation خروجی نوشته می شود. به‌طور پیش‌فرض، این هسته در کل Allocation ورودی‌اش اجرا می‌شود، با یک اجرای تابع هسته در هر Element در Allocation .

    یک هسته نگاشت ممکن است یک یا چند Allocations ورودی، یک Allocation خروجی واحد یا هر دو داشته باشد. زمان اجرا RenderScript بررسی می‌کند تا اطمینان حاصل شود که همه تخصیص‌های ورودی و خروجی دارای ابعاد یکسان هستند، و اینکه انواع Element تخصیص ورودی و خروجی با نمونه اولیه هسته مطابقت دارند. اگر هر یک از این بررسی ها ناموفق باشد، RenderScript یک استثنا ایجاد می کند.

    توجه: قبل از Android 6.0 (سطح API 23)، یک هسته نقشه برداری ممکن است بیش از یک Allocation ورودی نداشته باشد.

    اگر به Allocations ورودی یا خروجی بیشتری نسبت به هسته نیاز دارید، آن اشیا باید به اسکریپت های جهانی rs_allocation متصل شوند و از طریق یک هسته یا تابع فراخوانی از طریق rsGetElementAt_ type () یا rsSetElementAt_ type () قابل دسترسی باشند.

    توجه: RS_KERNEL یک ماکرو است که به طور خودکار توسط RenderScript برای راحتی شما تعریف شده است:

    #define RS_KERNEL __attribute__((kernel))

  هسته کاهشی خانواده ای از توابع است که بر روی مجموعه ای از Allocations ورودی با ابعاد مشابه عمل می کند. به طور پیش فرض، تابع انباشته آن برای هر مختصات در آن ابعاد یک بار اجرا می شود. معمولاً (اما نه به طور انحصاری) برای "کاهش" مجموعه ای از Allocations ورودی به یک مقدار واحد استفاده می شود.

  • در اینجا نمونه ای از یک هسته کاهش ساده است که Elements ورودی خود را جمع می کند:

    #pragma rs reduce(addint) accumulator(addintAccum)
    
    static void addintAccum(int *accum, int val) {
      *accum += val;
    }

    یک هسته کاهشی از یک یا چند تابع نوشته شده توسط کاربر تشکیل شده است. #pragma rs reduce برای تعریف کرنل با مشخص کردن نام آن ( addint ، در این مثال) و نام و نقش توابع تشکیل‌دهنده هسته (یک تابع accumulator addintAccum ، در این مثال) استفاده می‌شود. همه این توابع باید static باشند. یک هسته کاهش همیشه به یک تابع accumulator نیاز دارد. بسته به آنچه که می خواهید هسته انجام دهد، ممکن است عملکردهای دیگری نیز داشته باشد.

    یک تابع انباشته کننده هسته کاهش باید void برگرداند و باید حداقل دو آرگومان داشته باشد. آرگومان اول ( accum ، در این مثال) یک اشاره گر به یک آیتم داده انباشت کننده است و دومی ( val ، در این مثال) به طور خودکار براساس Allocation ورودی ارسال شده به راه اندازی هسته پر می شود. آیتم داده انباشته توسط زمان اجرا RenderScript ایجاد می شود. به طور پیش فرض، مقدار اولیه آن صفر است. به‌طور پیش‌فرض، این هسته در کل Allocation ورودی‌اش اجرا می‌شود، با یک اجرای تابع انباشته‌کننده در هر Element در Allocation . به طور پیش فرض، مقدار نهایی آیتم داده انباشته کننده به عنوان نتیجه کاهش در نظر گرفته می شود و به جاوا برگردانده می شود. زمان اجرا RenderScript بررسی می کند تا مطمئن شود که نوع Element تخصیص ورودی با نمونه اولیه تابع انطباق دهنده مطابقت دارد. اگر مطابقت نداشته باشد، RenderScript یک استثنا ایجاد می کند.

    یک هسته کاهش دارای یک یا چند Allocations ورودی است اما Allocations خروجی ندارد.

    هسته های کاهشی در اینجا با جزئیات بیشتری توضیح داده شده اند.

    هسته های کاهش در اندروید 7.0 (سطح API 24) و جدیدتر پشتیبانی می شوند.

  یک تابع هسته نگاشت یا یک تابع انباشته کننده هسته کاهشی ممکن است با استفاده از آرگومان های خاص x ، y و z که باید از نوع int یا uint32_t باشند، به مختصات اجرای فعلی دسترسی پیدا کند. این آرگومان ها اختیاری هستند.

  یک تابع هسته نگاشت یا یک تابع انباشته کننده هسته کاهش نیز ممکن است context آرگومان خاص اختیاری از نوع rs_kernel_context را بگیرد. این مورد برای خانواده ای از APIهای زمان اجرا مورد نیاز است که برای پرس و جو از ویژگی های خاص اجرای فعلی استفاده می شوند - برای مثال rsGetDimX . (آگومان context در Android 6.0 (سطح API 23) و جدیدتر موجود است.)

• یک تابع init() اختیاری. تابع init() نوع خاصی از تابع قابل فراخوانی است که RenderScript زمانی که اسکریپت برای اولین بار نمونه سازی می شود اجرا می کند. این اجازه می دهد تا برخی از محاسبات به طور خودکار هنگام ایجاد اسکریپت انجام شود.
• جهانی ها و توابع اسکریپت صفر یا بیشتر. یک اسکریپت استاتیک جهانی معادل یک اسکریپت جهانی است با این تفاوت که از کد جاوا قابل دسترسی نیست. یک تابع استاتیک یک تابع استاندارد C است که می تواند از هر هسته یا تابع فراخوانی در اسکریپت فراخوانی شود، اما در معرض Java API نیست. اگر یک اسکریپت جهانی یا تابع نیازی به دسترسی از کد جاوا نداشته باشد، بسیار توصیه می شود که آن را static اعلام کنید.

تنظیم دقت ممیز شناور

شما می توانید سطح مورد نیاز از دقت ممیز شناور را در یک اسکریپت کنترل کنید. اگر استاندارد کامل IEEE 754-2008 (به طور پیش فرض استفاده می شود) مورد نیاز نباشد، مفید است. پراگماهای زیر می توانند سطح متفاوتی از دقت ممیز شناور را تعیین کنند:

• #pragma rs_fp_full (پیش‌فرض اگر چیزی مشخص نشده باشد): برای برنامه‌هایی که به دقت ممیز شناور طبق استاندارد IEEE 754-2008 نیاز دارند.
• #pragma rs_fp_relaxed : برای برنامه هایی که به انطباق دقیق IEEE 754-2008 نیاز ندارند و می توانند دقت کمتری را تحمل کنند. این حالت تراز به صفر را برای دنورم و دور به سمت صفر را فعال می کند.
• #pragma rs_fp_imprecise : برای برنامه هایی که الزامات دقیق دقیقی ندارند. این حالت همه چیز را در rs_fp_relaxed به همراه موارد زیر فعال می کند:
  • عملیاتی که منجر به -0.0 می شود می تواند در عوض +0.0 را برگرداند.
  • عملیات روی INF و NAN تعریف نشده است.

اکثر برنامه ها می توانند از rs_fp_relaxed بدون هیچ گونه عوارض جانبی استفاده کنند. این ممکن است در برخی از معماری‌ها به دلیل بهینه‌سازی‌های اضافی که فقط با دقت آرام در دسترس هستند (مانند دستورالعمل‌های CPU SIMD) بسیار سودمند باشد.

دسترسی به API های RenderScript از جاوا

هنگام توسعه یک برنامه اندرویدی که از RenderScript استفاده می کند، می توانید به یکی از دو روش از جاوا به API آن دسترسی داشته باشید:

• android.renderscript - APIهای این بسته کلاسی در دستگاه‌های دارای Android نسخه 3.0 (سطح API 11) و بالاتر در دسترس هستند.
• android.support.v8.renderscript - APIهای موجود در این بسته از طریق کتابخانه پشتیبانی در دسترس هستند که به شما امکان می دهد از آنها در دستگاه های دارای Android نسخه 2.3 (سطح API 9) و بالاتر استفاده کنید.

در اینجا معاوضه ها وجود دارد:

• اگر از API های کتابخانه پشتیبانی استفاده می کنید، بخش RenderScript برنامه شما با دستگاه های دارای Android نسخه 2.3 (سطح API 9) و بالاتر سازگار خواهد بود، صرف نظر از اینکه از کدام ویژگی های RenderScript استفاده می کنید. این به برنامه شما اجازه می دهد تا در دستگاه های بیشتری نسبت به زمانی که از API های بومی ( android.renderscript ) استفاده می کنید، کار کند.
• برخی از ویژگی‌های RenderScript از طریق APIهای کتابخانه پشتیبانی در دسترس نیستند.
• اگر از APIهای کتابخانه پشتیبانی استفاده کنید، APKهای بزرگتری (احتمالاً به طور قابل توجهی) نسبت به APIهای بومی ( android.renderscript ) دریافت خواهید کرد.

با استفاده از APIهای کتابخانه پشتیبانی RenderScript

برای استفاده از API های RenderScript کتابخانه پشتیبانی، باید محیط توسعه خود را پیکربندی کنید تا بتوانید به آنها دسترسی داشته باشید. ابزار Android SDK زیر برای استفاده از این APIها مورد نیاز است:

• نسخه 22.2 یا بالاتر Android SDK Tools
• نسخه 18.1.0 یا بالاتر Android SDK Build-tools

توجه داشته باشید که از Android SDK Build-tools 24.0.0، Android 2.2 (سطح API 8) دیگر پشتیبانی نمی‌شود.

می توانید نسخه نصب شده این ابزارها را در Android SDK Manager بررسی و به روز کنید.

برای استفاده از پشتیبانی کتابخانه RenderScript API:

1. مطمئن شوید که نسخه Android SDK مورد نیاز را نصب کرده اید.
2. تنظیمات فرآیند ساخت اندروید را به‌روزرسانی کنید تا تنظیمات RenderScript را نیز شامل شود:
   • فایل build.gradle را در پوشه برنامه ماژول برنامه خود باز کنید.
   • تنظیمات RenderScript زیر را به فایل اضافه کنید:

     شیار

             android {
                 compileSdkVersion 33
     
                 defaultConfig {
                     minSdkVersion 9
                     targetSdkVersion 19
     
                     renderscriptTargetApi 18
                     renderscriptSupportModeEnabled true
                 }
             }
             

     کاتلین

             android {
                 compileSdkVersion(33)
     
                 defaultConfig {
                     minSdkVersion(9)
                     targetSdkVersion(19)
     
                     renderscriptTargetApi = 18
                     renderscriptSupportModeEnabled = true
                 }
             }
             

     تنظیمات لیست شده در بالا رفتار خاصی را در فرآیند ساخت اندروید کنترل می کنند:

     • renderscriptTargetApi - نسخه بایت کدی را که باید تولید شود را مشخص می کند. توصیه می‌کنیم این مقدار را روی پایین‌ترین سطح API تنظیم کنید که می‌تواند تمام عملکردهایی را که استفاده می‌کنید ارائه کند و renderscriptSupportModeEnabled روی true تنظیم کنید. مقادیر معتبر برای این تنظیم هر عدد صحیحی از 11 تا آخرین سطح API منتشر شده است. اگر حداقل نسخه SDK مشخص شده در مانیفست برنامه شما روی مقدار دیگری تنظیم شده باشد، آن مقدار نادیده گرفته می شود و مقدار هدف در فایل ساخت برای تنظیم حداقل نسخه SDK استفاده می شود.
     • renderscriptSupportModeEnabled - مشخص می کند که اگر دستگاهی که روی آن اجرا می شود نسخه هدف را پشتیبانی نمی کند، بایت کد تولید شده باید به نسخه سازگار برگردد.
3. در کلاس های برنامه خود که از RenderScript استفاده می کنند، یک import برای کلاس های کتابخانه پشتیبانی اضافه کنید:

   کاتلین

   import android.support.v8.renderscript.*

   جاوا

   import android.support.v8.renderscript.*;

با استفاده از RenderScript از جاوا یا کد Kotlin

استفاده از RenderScript از کد جاوا یا Kotlin به کلاس های API واقع در بسته android.renderscript یا android.support.v8.renderscript متکی است. اکثر برنامه ها از همان الگوی استفاده اولیه پیروی می کنند:

1. یک زمینه RenderScript را راه اندازی کنید. زمینه RenderScript که با create(Context) ایجاد شده است، اطمینان می دهد که RenderScript می تواند مورد استفاده قرار گیرد و یک شی برای کنترل طول عمر تمام اشیاء RenderScript بعدی ارائه می دهد. شما باید ایجاد زمینه را یک عملیات بالقوه طولانی مدت در نظر بگیرید، زیرا ممکن است منابعی را روی قطعات مختلف سخت افزار ایجاد کند. در صورت امکان نباید در مسیر بحرانی برنامه قرار گیرد. به طور معمول، یک برنامه در هر زمان تنها یک زمینه RenderScript دارد.
2. حداقل یک Allocation برای ارسال به یک اسکریپت ایجاد کنید. Allocation یک شی RenderScript است که برای مقدار ثابتی از داده ها ذخیره می کند. هسته‌های موجود در اسکریپت‌ها، اشیاء Allocation به عنوان ورودی و خروجی خود می‌گیرند، و اشیاء Allocation می‌توان در هسته‌ها با استفاده rsGetElementAt_ type () و rsSetElementAt_ type () هنگامی که به‌عنوان جهانی‌های اسکریپت محدود می‌شود، دسترسی داشت. اشیاء Allocation آرایه ها اجازه می دهد تا از کد جاوا به کد RenderScript و بالعکس منتقل شوند. اشیاء Allocation معمولاً با استفاده از createTyped() یا createFromBitmap() ایجاد می شوند.
3. هر اسکریپت لازم را ایجاد کنید. هنگام استفاده از RenderScript دو ​​نوع اسکریپت در دسترس شماست:
   • ScriptC : اینها اسکریپت های تعریف شده توسط کاربر هستند که در بالا توضیح داده شد . هر اسکریپت دارای یک کلاس جاوا است که توسط کامپایلر RenderScript منعکس شده است تا دسترسی به اسکریپت از کد جاوا آسان شود. این کلاس دارای نام ScriptC_ filename است. برای مثال، اگر هسته نگاشت فوق در invert.rs قرار داشته باشد و یک زمینه RenderScript قبلاً در mRenderScript قرار داشته باشد، کد جاوا یا Kotlin برای نمونه سازی اسکریپت به این صورت خواهد بود:

     کاتلین

     val invert = ScriptC_invert(renderScript)

     جاوا

     ScriptC_invert invert = new ScriptC_invert(renderScript);

   • ScriptIntrinsic : اینها هسته‌های RenderScript داخلی برای عملیات رایج مانند تاری گاوسی، کانولوشن و ترکیب تصویر هستند. برای اطلاعات بیشتر، به زیر کلاس های ScriptIntrinsic مراجعه کنید.
4. تخصیص ها را با داده ها پر کنید. به‌جز تخصیص‌هایی که با createFromBitmap() ایجاد می‌شوند، یک تخصیص زمانی که برای اولین بار ایجاد می‌شود با داده‌های خالی پر می‌شود. برای پر کردن یک تخصیص، از یکی از روش‌های «کپی» در Allocation استفاده کنید. روش های "کپی" همزمان هستند.
5. هر جهانی اسکریپت لازم را تنظیم کنید. می‌توانید با استفاده از روش‌هایی در همان کلاس ScriptC_ filename با نام set_ globalname جهانی‌ها را تنظیم کنید. به عنوان مثال، برای تنظیم یک متغیر int به نام threshold ، از متد جاوا set_threshold(int) استفاده کنید. و برای تنظیم یک متغیر rs_allocation با نام lookup ، از متد جاوا set_lookup(Allocation) استفاده کنید. روش های set ناهمزمان هستند.
6. هسته های مناسب و توابع فراخوانی را راه اندازی کنید.

   روش‌های راه‌اندازی یک هسته مشخص در همان کلاس ScriptC_ filename با روش‌هایی با نام‌های forEach_ mappingKernelName () یا reduce_ reductionKernelName () منعکس می‌شوند. این راه اندازی ها ناهمزمان هستند. بسته به آرگومان های هسته، متد یک یا چند تخصیص می گیرد که همه آنها باید ابعاد یکسانی داشته باشند. به طور پیش فرض، یک هسته روی هر مختصاتی در آن ابعاد اجرا می شود. برای اجرای یک هسته بر روی زیرمجموعه ای از آن مختصات، یک Script.LaunchOptions مناسب را به عنوان آخرین آرگومان به متد forEach یا reduce ارسال کنید.

   توابع قابل فراخوانی را با استفاده از متدهای invoke_ functionName که در همان کلاس ScriptC_ filename منعکس شده است، راه اندازی کنید. این راه اندازی ها ناهمزمان هستند.

7. بازیابی داده ها از اشیاء Allocation و javaFutureType . برای دسترسی به داده‌های یک Allocation از کد جاوا، باید آن داده‌ها را با استفاده از یکی از روش‌های «کپی» در Allocation به جاوا کپی کنید. برای به دست آوردن نتیجه یک هسته کاهش، باید از متد javaFutureType .get() استفاده کنید. متدهای "copy" و get() همزمان هستند.
8. زمینه RenderScript را از بین ببرید. شما می توانید زمینه RenderScript را با destroy() یا با اجازه دادن به آبجکت زمینه RenderScript برای جمع آوری زباله از بین ببرید. این باعث می شود که هر گونه استفاده بیشتر از هر شی متعلق به آن زمینه، یک استثنا ایجاد کند.

مدل اجرای ناهمزمان

متدهای منعکس شده forEach ، invoke ، reduce و set ناهمزمان هستند - هر کدام ممکن است قبل از تکمیل عمل درخواستی به جاوا بازگردند. با این حال، اقدامات فردی به ترتیبی که راه اندازی می شوند سریال می شوند.

کلاس Allocation متدهای "کپی" را برای کپی کردن داده ها به و از Allocations فراهم می کند. یک روش "کپی" همزمان است و با توجه به هر یک از اقدامات ناهمزمان بالا که همان تخصیص را لمس می کنند، سریال سازی می شود.

کلاس های javaFutureType منعکس شده یک متد get() برای به دست آوردن نتیجه کاهش ارائه می کنند. get() همزمان است و با توجه به کاهش (که ناهمزمان است) سریال می شود.

RenderScript تک منبعی

Android 7.0 (سطح API 24) یک ویژگی برنامه نویسی جدید به نام Single-Source RenderScript را معرفی می کند که در آن هسته ها از اسکریپتی که در آن تعریف شده اند، به جای جاوا راه اندازی می شوند. این رویکرد در حال حاضر محدود به هسته‌های نقشه‌برداری است که در این بخش برای مختصر به آن‌ها به سادگی به عنوان «کرنل» یاد می‌شود. این ویژگی جدید همچنین از ایجاد تخصیص هایی از نوع rs_allocation از داخل اسکریپت پشتیبانی می کند. اکنون می‌توان یک الگوریتم کامل را تنها در یک اسکریپت پیاده‌سازی کرد، حتی اگر چندین راه‌اندازی هسته مورد نیاز باشد. مزیت دو جانبه است: کد قابل خواندن تر، زیرا اجرای الگوریتم را در یک زبان حفظ می کند. و کد بالقوه سریعتر، به دلیل انتقال کمتر بین جاوا و رندر اسکریپت در راه اندازی چندین هسته.

در RenderScript تک منبعی، شما هسته ها را همانطور که در نوشتن یک هسته RenderScript توضیح داده شده است، می نویسید. سپس یک تابع فراخوانی می نویسید که rsForEach() را فرا می خواند تا آنها را راه اندازی کند. آن API یک تابع هسته را به عنوان اولین پارامتر و به دنبال آن تخصیص ورودی و خروجی می گیرد. یک API مشابه rsForEachWithOptions() یک آرگومان اضافی از نوع rs_script_call_t می گیرد که زیرمجموعه ای از عناصر را از تخصیص های ورودی و خروجی برای عملکرد هسته برای پردازش مشخص می کند.

برای شروع محاسبات RenderScript، تابع فراخوانی را از جاوا فراخوانی می کنید. مراحل استفاده از RenderScript از کد جاوا را دنبال کنید. در مرحله راه‌اندازی هسته‌های مناسب ، تابع invokable را با استفاده از invoke_ function_name () فراخوانی کنید، که کل محاسبات، از جمله راه‌اندازی هسته‌ها را آغاز می‌کند.

تخصیص ها اغلب برای ذخیره و انتقال نتایج میانی از یک هسته به کرنل دیگر مورد نیاز است. می توانید آنها را با استفاده از rsCreateAllocation() ایجاد کنید. یکی از اشکال آسان برای استفاده از آن API rsCreateAllocation_<T><W>(…) است که در آن T نوع داده برای یک عنصر و W عرض برداری برای عنصر است. API اندازه های ابعاد X، Y و Z را به عنوان آرگومان می گیرد. برای تخصیص یک بعدی یا دو بعدی، اندازه ابعاد Y یا Z را می توان حذف کرد. برای مثال، rsCreateAllocation_uchar4(16384) یک تخصیص 1 بعدی از 16384 عنصر ایجاد می کند که هر کدام از آنها از نوع uchar4 است.

تخصیص ها توسط سیستم به صورت خودکار مدیریت می شوند. شما مجبور نیستید آنها را به صراحت آزاد یا آزاد کنید. با این حال، می‌توانید با rsClearObject(rs_allocation* alloc) تماس بگیرید تا نشان دهید دیگر نیازی به alloc دسته برای تخصیص اصلی ندارید، تا سیستم بتواند منابع را در اسرع وقت آزاد کند.

بخش Writing a RenderScript Kernel شامل یک هسته نمونه است که یک تصویر را معکوس می کند. مثال زیر آن را برای اعمال بیش از یک افکت بر روی یک تصویر، با استفاده از RenderScript تک منبعی گسترش می دهد. این شامل هسته دیگری greyscale است که یک تصویر رنگی را به سیاه و سفید تبدیل می کند. سپس یک تابع فراخوانی process() آن دو هسته را به طور متوالی بر روی یک تصویر ورودی اعمال می کند و یک تصویر خروجی تولید می کند. تخصیص ها برای ورودی و خروجی به عنوان آرگومان هایی از نوع rs_allocation ارسال می شوند.

// File: singlesource.rs

#pragma version(1)
#pragma rs java_package_name(com.android.rssample)

static const float4 weight = {0.299f, 0.587f, 0.114f, 0.0f};

uchar4 RS_KERNEL invert(uchar4 in, uint32_t x, uint32_t y) {
  uchar4 out = in;
  out.r = 255 - in.r;
  out.g = 255 - in.g;
  out.b = 255 - in.b;
  return out;
}

uchar4 RS_KERNEL greyscale(uchar4 in) {
  const float4 inF = rsUnpackColor8888(in);
  const float4 outF = (float4){ dot(inF, weight) };
  return rsPackColorTo8888(outF);
}

void process(rs_allocation inputImage, rs_allocation outputImage) {
  const uint32_t imageWidth = rsAllocationGetDimX(inputImage);
  const uint32_t imageHeight = rsAllocationGetDimY(inputImage);
  rs_allocation tmp = rsCreateAllocation_uchar4(imageWidth, imageHeight);
  rsForEach(invert, inputImage, tmp);
  rsForEach(greyscale, tmp, outputImage);
}

می توانید تابع process() از جاوا یا کاتلین به صورت زیر فراخوانی کنید:

val RS: RenderScript = RenderScript.create(context)
val script = ScriptC_singlesource(RS)
val inputAllocation: Allocation = Allocation.createFromBitmapResource(
        RS,
        resources,
        R.drawable.image
)
val outputAllocation: Allocation = Allocation.createTyped(
        RS,
        inputAllocation.type,
        Allocation.USAGE_SCRIPT or Allocation.USAGE_IO_OUTPUT
)
script.invoke_process(inputAllocation, outputAllocation)

// File SingleSource.java

RenderScript RS = RenderScript.create(context);
ScriptC_singlesource script = new ScriptC_singlesource(RS);
Allocation inputAllocation = Allocation.createFromBitmapResource(
    RS, getResources(), R.drawable.image);
Allocation outputAllocation = Allocation.createTyped(
    RS, inputAllocation.getType(),
    Allocation.USAGE_SCRIPT | Allocation.USAGE_IO_OUTPUT);
script.invoke_process(inputAllocation, outputAllocation);

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

جهانی های اسکریپت

یک اسکریپت جهانی یک متغیر جهانی static معمولی در یک فایل اسکریپت ( .rs ) است. برای یک اسکریپت جهانی با نام var که در filename .rs تعریف شده است، یک روش get_ var در کلاس ScriptC_ filename منعکس شده است. مگر اینکه global const باشد، متد set_ var نیز وجود خواهد داشت.

یک اسکریپت جهانی دو مقدار جداگانه دارد - یک مقدار جاوا و یک مقدار اسکریپت . این مقادیر به صورت زیر عمل می کنند:

• اگر var در اسکریپت دارای مقدار اولیه استاتیک باشد، مقدار اولیه var را هم در جاوا و هم در اسکریپت مشخص می کند. در غیر این صورت، آن مقدار اولیه صفر است.
• دسترسی به var در داخل اسکریپت مقدار اسکریپت آن را می خواند و می نویسد.
• متد get_ var مقدار جاوا را می خواند.
• متد set_ var (اگر وجود داشته باشد) مقدار جاوا را فوراً می نویسد و مقدار اسکریپت را به صورت ناهمزمان می نویسد.

توجه: این بدان معنی است که به جز هر مقدار اولیه ایستا در اسکریپت، مقادیری که از داخل یک اسکریپت به یک global نوشته شده است برای جاوا قابل مشاهده نیستند.

کاهش هسته ها در عمق

کاهش فرآیند ترکیب مجموعه ای از داده ها در یک مقدار واحد است. این یک نرم افزار ابتدایی مفید در برنامه نویسی موازی با برنامه هایی مانند موارد زیر است:

• محاسبه مجموع یا محصول بر روی تمام داده ها
• محاسبه عملیات منطقی ( and ، or ، xor ) روی همه داده ها
• یافتن حداقل یا حداکثر مقدار در داده ها
• جستجو برای یک مقدار خاص یا مختصات یک مقدار خاص در داده ها

در Android 7.0 (سطح API 24) و نسخه‌های جدیدتر، RenderScript از هسته‌های کاهش پشتیبانی می‌کند تا الگوریتم‌های کاهش کارآمد نوشته‌شده توسط کاربر را امکان‌پذیر کند. می توانید هسته های کاهشی را روی ورودی هایی با ابعاد 1، 2 یا 3 راه اندازی کنید.

مثال بالا یک هسته کاهش افزودنی ساده را نشان می دهد. در اینجا یک هسته کاهش findMinAndMax پیچیده تر است که مکان های حداقل و حداکثر مقادیر long را در یک Allocation 1 بعدی پیدا می کند:

#define LONG_MAX (long)((1UL << 63) - 1)
#define LONG_MIN (long)(1UL << 63)

#pragma rs reduce(findMinAndMax) \
  initializer(fMMInit) accumulator(fMMAccumulator) \
  combiner(fMMCombiner) outconverter(fMMOutConverter)

// Either a value and the location where it was found, or INITVAL.
typedef struct {
  long val;
  int idx;     // -1 indicates INITVAL
} IndexedVal;

typedef struct {
  IndexedVal min, max;
} MinAndMax;

// In discussion below, this initial value { { LONG_MAX, -1 }, { LONG_MIN, -1 } }
// is called INITVAL.
static void fMMInit(MinAndMax *accum) {
  accum->min.val = LONG_MAX;
  accum->min.idx = -1;
  accum->max.val = LONG_MIN;
  accum->max.idx = -1;
}

//----------------------------------------------------------------------
// In describing the behavior of the accumulator and combiner functions,
// it is helpful to describe hypothetical functions
//   IndexedVal min(IndexedVal a, IndexedVal b)
//   IndexedVal max(IndexedVal a, IndexedVal b)
//   MinAndMax  minmax(MinAndMax a, MinAndMax b)
//   MinAndMax  minmax(MinAndMax accum, IndexedVal val)
//
// The effect of
//   IndexedVal min(IndexedVal a, IndexedVal b)
// is to return the IndexedVal from among the two arguments
// whose val is lesser, except that when an IndexedVal
// has a negative index, that IndexedVal is never less than
// any other IndexedVal; therefore, if exactly one of the
// two arguments has a negative index, the min is the other
// argument. Like ordinary arithmetic min and max, this function
// is commutative and associative; that is,
//
//   min(A, B) == min(B, A)               // commutative
//   min(A, min(B, C)) == min((A, B), C)  // associative
//
// The effect of
//   IndexedVal max(IndexedVal a, IndexedVal b)
// is analogous (greater . . . never greater than).
//
// Then there is
//
//   MinAndMax minmax(MinAndMax a, MinAndMax b) {
//     return MinAndMax(min(a.min, b.min), max(a.max, b.max));
//   }
//
// Like ordinary arithmetic min and max, the above function
// is commutative and associative; that is:
//
//   minmax(A, B) == minmax(B, A)                  // commutative
//   minmax(A, minmax(B, C)) == minmax((A, B), C)  // associative
//
// Finally define
//
//   MinAndMax minmax(MinAndMax accum, IndexedVal val) {
//     return minmax(accum, MinAndMax(val, val));
//   }
//----------------------------------------------------------------------

// This function can be explained as doing:
//   *accum = minmax(*accum, IndexedVal(in, x))
//
// This function simply computes minimum and maximum values as if
// INITVAL.min were greater than any other minimum value and
// INITVAL.max were less than any other maximum value.  Note that if
// *accum is INITVAL, then this function sets
//   *accum = IndexedVal(in, x)
//
// After this function is called, both accum->min.idx and accum->max.idx
// will have nonnegative values:
// - x is always nonnegative, so if this function ever sets one of the
//   idx fields, it will set it to a nonnegative value
// - if one of the idx fields is negative, then the corresponding
//   val field must be LONG_MAX or LONG_MIN, so the function will always
//   set both the val and idx fields
static void fMMAccumulator(MinAndMax *accum, long in, int x) {
  IndexedVal me;
  me.val = in;
  me.idx = x;

  if (me.val <= accum->min.val)
    accum->min = me;
  if (me.val >= accum->max.val)
    accum->max = me;
}

// This function can be explained as doing:
//   *accum = minmax(*accum, *val)
//
// This function simply computes minimum and maximum values as if
// INITVAL.min were greater than any other minimum value and
// INITVAL.max were less than any other maximum value.  Note that if
// one of the two accumulator data items is INITVAL, then this
// function sets *accum to the other one.
static void fMMCombiner(MinAndMax *accum,
                        const MinAndMax *val) {
  if ((accum->min.idx < 0) || (val->min.val < accum->min.val))
    accum->min = val->min;
  if ((accum->max.idx < 0) || (val->max.val > accum->max.val))
    accum->max = val->max;
}

static void fMMOutConverter(int2 *result,
                            const MinAndMax *val) {
  result->x = val->min.idx;
  result->y = val->max.idx;
}

توجه: هسته های کاهش نمونه بیشتری در اینجا وجود دارد.

به منظور اجرای یک هسته کاهش، زمان اجرا RenderScript یک یا چند متغیر به نام آیتم های داده انباشته ساز ایجاد می کند تا وضعیت فرآیند کاهش را حفظ کند. زمان اجرا RenderScript تعداد آیتم های داده انباشته کننده را به گونه ای انتخاب می کند که عملکرد را به حداکثر برساند. نوع اقلام داده های انباشته کننده ( accumType ) توسط تابع انباشته کننده هسته تعیین می شود -- اولین آرگومان آن تابع یک اشاره گر به یک آیتم داده انباشته است. به طور پیش‌فرض، هر آیتم داده انباشته‌کننده به صفر مقدار دهی اولیه می‌شود (مثلاً توسط memset ). با این حال، می توانید یک تابع اولیه برای انجام کاری متفاوت بنویسید.

مثال: در هسته addint ، اقلام داده انباشت کننده (از نوع int ) برای جمع کردن مقادیر ورودی استفاده می شود. هیچ تابع اولیه وجود ندارد، بنابراین هر آیتم داده انباشته به صفر مقداردهی اولیه می شود.

مثال: در هسته findMinAndMax ، اقلام داده انباشته کننده (از نوع MinAndMax ) برای پیگیری حداقل و حداکثر مقادیر یافت شده تا کنون استفاده می شود. یک تابع اولیه وجود دارد که اینها را به ترتیب روی LONG_MAX و LONG_MIN تنظیم می کند. و برای تنظیم مکان این مقادیر به -1، که نشان می دهد که مقادیر در واقع در بخش (خالی) ورودی پردازش شده وجود ندارند.

RenderScript تابع انباشتگر شما را یکبار برای هر مختصات در ورودی(ها) فراخوانی می کند. به طور معمول، تابع شما باید آیتم داده انباشته کننده را به نحوی مطابق با ورودی به روز کند.

مثال: در هسته addint ، تابع accumulator مقدار یک عنصر ورودی را به آیتم داده accumulator اضافه می کند.

مثال: در هسته findMinAndMax ، تابع انباشتگر بررسی می کند که آیا مقدار یک عنصر ورودی کمتر یا مساوی با حداقل مقدار ثبت شده در آیتم داده انباشت کننده و/یا بزرگتر یا مساوی با حداکثر مقدار ثبت شده در انباشته است یا خیر. مورد داده، و مورد داده انباشته کننده را بر این اساس به روز می کند.

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

مثال: در کرنل addint ، تابع ترکیبی وجود ندارد، بنابراین از تابع accumulator استفاده خواهد شد. این رفتار درستی است، زیرا اگر مجموعه ای از مقادیر را به دو قسمت تقسیم کنیم و مقادیر آن دو قطعه را جداگانه جمع کنیم، جمع کردن آن دو مجموع مانند جمع کردن کل مجموعه است.

مثال: در هسته findMinAndMax ، تابع ترکیب کننده بررسی می کند که آیا حداقل مقدار ثبت شده در آیتم داده انباشته کننده "منبع" *val کمتر از حداقل مقدار ثبت شده در مورد داده انباشته کننده "مقصد" *accum است یا خیر، و *accum را به روز می کند. بر این اساس. کار مشابهی را برای حداکثر مقدار انجام می دهد. این *accum به حالتی به روز می کند که اگر همه مقادیر ورودی در *accum جمع می شدند به جای برخی در *accum و برخی در *val انباشته می شدند.

پس از اینکه همه موارد داده های انباشته با هم ترکیب شدند، RenderScript نتیجه کاهش را برای بازگشت به جاوا تعیین می کند. برای انجام این کار، می توانید یک تابع تبدیل کننده بنویسید. اگر می خواهید مقدار نهایی اقلام داده های انباشته کننده ترکیبی نتیجه کاهش باشد، نیازی به نوشتن تابع مبدل برون نیست.

مثال: در کرنل addint ، هیچ تابع مبدل برون وجود ندارد. مقدار نهایی اقلام داده ترکیبی مجموع تمام عناصر ورودی است که مقداری است که می خواهیم برگردانیم.

مثال: در هسته findMinAndMax ، تابع outconverter یک مقدار نتیجه int2 را مقداردهی اولیه می‌کند تا مکان‌های حداقل و حداکثر مقادیر حاصل از ترکیب همه آیتم‌های داده انباشته را نگه دارد.

نوشتن یک هسته کاهش

#pragma rs reduce یک هسته کاهش را با مشخص کردن نام آن و نام و نقش توابع تشکیل دهنده هسته تعریف می کند. همه این توابع باید static باشند. یک هسته کاهش همیشه به یک تابع accumulator نیاز دارد. بسته به کاری که می‌خواهید هسته انجام دهد، می‌توانید برخی یا همه توابع دیگر را حذف کنید.

#pragma rs reduce(kernelName) \
  initializer(initializerName) \
  accumulator(accumulatorName) \
  combiner(combinerName) \
  outconverter(outconverterName)

معنی موارد موجود در #pragma به شرح زیر است:

• reduce( kernelName ) (اجباری): مشخص می کند که یک هسته کاهش تعریف می شود. یک روش جاوای منعکس شده reduce_ kernelName هسته را راه اندازی می کند.

• initializer( initializerName ) (اختیاری): نام تابع اولیه را برای این هسته کاهشی مشخص می کند. هنگامی که هسته را راه اندازی می کنید، RenderScript این تابع را یک بار برای هر آیتم داده انباشته کننده فراخوانی می کند. تابع باید به صورت زیر تعریف شود:

  static void initializerName(accumType *accum) { … }

  accum یک اشاره گر به یک آیتم داده انباشت کننده برای مقداردهی اولیه این تابع است.

  اگر یک تابع اولیه ارائه نکنید، RenderScript هر آیتم داده انباشته‌کننده را صفر می‌کند (مثلاً توسط memset )، طوری رفتار می‌کند که انگار یک تابع اولیه وجود دارد که شبیه این است:

  static void initializerName(accumType *accum) {
    memset(accum, 0, sizeof(*accum));
  }

• accumulator( accumulatorName ) (اجباری): نام تابع accumulator را برای این هسته کاهشی مشخص می کند. هنگامی که هسته را راه اندازی می کنید، RenderScript این تابع را یکبار برای هر مختصات در ورودی(ها) فراخوانی می کند تا یک آیتم داده انباشته کننده را به نحوی مطابق با ورودی(ها) به روز کند. تابع باید به صورت زیر تعریف شود:

  static void accumulatorName(accumType *accum,
                              in1Type in1, …, inNType inN
                              [, specialArguments]) { … }

  accum یک اشاره گر به یک آیتم داده انباشته برای این تابع برای تغییر است. in1 تا in N یک یا چند آرگومان هستند که به طور خودکار بر اساس ورودی‌های ارسال شده به راه‌اندازی هسته، یک آرگومان در هر ورودی، پر می‌شوند. تابع accumulator ممکن است به صورت اختیاری هر یک از آرگومان های خاص را بگیرد.

  یک هسته نمونه با چندین ورودی، dotProduct است.

• combiner( combinerName )

  (اختیاری): نام تابع ترکیب کننده را برای این هسته کاهشی مشخص می کند. پس از اینکه RenderScript تابع انباشت کننده را یک بار برای هر مختصات در ورودی(ها) فراخوانی کرد، این تابع را هر چند بار که لازم است برای ترکیب همه آیتم های داده انباشته در یک آیتم داده انباشته کننده واحد فراخوانی می کند. تابع باید به صورت زیر تعریف شود:

  static void combinerName(accumType *accum, const accumType *other) { … }

  accum یک اشاره گر به یک آیتم داده انباشت کننده "مقصد" است که این تابع را تغییر می دهد. other یک اشاره گر به یک آیتم داده انباشت کننده "منبع" برای "ترکیب" این تابع در *accum است.

  توجه: ممکن است *accum ، *other ، یا هر دو مقداردهی اولیه شده باشند اما هرگز به تابع accumulator منتقل نشده باشند. یعنی یک یا هر دو هرگز طبق هیچ داده ورودی به روز نشده اند. به عنوان مثال، در هسته findMinAndMax ، تابع ترکیبی fMMCombiner صریحاً idx < 0 را بررسی می‌کند، زیرا چنین آیتم داده انباشته‌ای را نشان می‌دهد که مقدار آن INITVAL است.

  اگر یک تابع ترکیبی ارائه نکنید، RenderScript از تابع ادغام کننده در جای خود استفاده می کند، طوری رفتار می کند که گویی یک تابع ترکیبی وجود دارد که به شکل زیر است:

  static void combinerName(accumType *accum, const accumType *other) {
    accumulatorName(accum, *other);
  }

  اگر هسته بیش از یک ورودی داشته باشد، اگر نوع داده ورودی با نوع داده انباشته‌کننده یکسان نباشد، یا اگر تابع انباشته یک یا چند آرگومان خاص داشته باشد، یک تابع ترکیب‌کننده اجباری است.

• outconverter( outconverterName ) (اختیاری): نام تابع تبدیل کننده را برای این هسته کاهشی مشخص می کند. پس از اینکه RenderScript همه اقلام داده های انباشته کننده را ترکیب کرد، این تابع را فراخوانی می کند تا نتیجه کاهش را برای بازگشت به جاوا مشخص کند. تابع باید به صورت زیر تعریف شود:

  static void outconverterName(resultType *result, const accumType *accum) { … }

  result یک اشاره گر به یک آیتم داده نتیجه است (تخصیص داده شده اما توسط زمان اجرا RenderScript مقداردهی اولیه نشده است) تا این تابع با نتیجه کاهش مقداردهی اولیه شود. resultType نوع آن آیتم داده است که نیازی به مشابه accumType ندارد. accum یک اشاره گر به آیتم داده انباشته نهایی است که توسط تابع ترکیب کننده محاسبه می شود.

  اگر تابع مبدل برون‌کنار ارائه نکنید، RenderScript آیتم داده‌های جمع‌آوری نهایی را در آیتم داده نتیجه کپی می‌کند، به گونه‌ای رفتار می‌کند که گویی یک تابع مبدل برون‌گرا وجود دارد که شبیه این است:

  static void outconverterName(accumType *result, const accumType *accum) {
    *result = *accum;
  }

  اگر نوع نتیجه متفاوتی نسبت به نوع داده انباشته می خواهید، عملکرد مبدل برون اجباری است.

توجه داشته باشید که یک کرنل دارای انواع ورودی، نوع آیتم داده انباشته کننده و نوع نتیجه است که هیچ کدام نیازی به یکسان بودن ندارند. به عنوان مثال، در هسته findMinAndMax ، نوع ورودی long ، نوع داده جمع‌آوری MinAndMax و نوع نتیجه int2 متفاوت است.

چه چیزی را نمی توانید فرض کنید؟

برای راه اندازی هسته معین نباید به تعداد آیتم های داده انباشته کننده ایجاد شده توسط RenderScript تکیه کنید. هیچ تضمینی وجود ندارد که دو راه‌اندازی از یک هسته با ورودی(های) یکسان، تعداد یکسانی از آیتم‌های داده انباشته‌کننده را ایجاد کند.

شما نباید به نظمی که RenderScript با عملکردهای اولیه ، باتری و ترکیبات Combiner تماس می گیرد ، اعتماد کنید. حتی ممکن است برخی از آنها را به طور موازی صدا کند. هیچ تضمینی وجود ندارد که دو پرتاب از همان هسته با همان ورودی از همان ترتیب پیروی کنند. تنها ضمانت این است که فقط عملکرد اولیه سازنده یک مورد داده باتری غیرمجاز را مشاهده می کند. به عنوان مثال:

• هیچ تضمینی وجود ندارد که قبل از فراخوانی عملکرد باتری ، تمام موارد داده های باتری اولیه اولیه شود ، اگرچه فقط در مورد یک مورد داده های جمع کننده اولیه فراخوانی می شود.
• هیچ تضمینی در مورد ترتیب انتقال عناصر ورودی به عملکرد باتری وجود ندارد.
• هیچ تضمینی وجود ندارد که قبل از فراخوانی عملکرد Combiner ، عملکرد باتری برای همه عناصر ورودی فراخوانی شده باشد.

یک نتیجه از این امر این است که هسته FindminandMax قطعی نیست: اگر ورودی حاوی بیش از یک مورد با حداقل ارزش یا حداکثر باشد ، شما هیچ راهی برای دانستن اینکه هسته را پیدا می کند ، ندارید.

چه چیزی را باید تضمین کنید؟

از آنجا که سیستم RenderScript می تواند به روش های مختلف هسته را اجرا کند ، باید از قوانین خاصی پیروی کنید تا اطمینان حاصل شود که هسته شما به روشی که می خواهید رفتار می کند. اگر این قوانین را رعایت نکنید ، ممکن است نتایج نادرست ، رفتار غیر تعیین کننده یا خطاهای زمان اجرا را بدست آورید.

قوانین زیر اغلب می گویند که دو مورد داده باتلاق باید " یک مقدار" داشته باشند. این به چه معناست؟ این بستگی به کاری دارد که شما می خواهید هسته انجام دهد. برای کاهش ریاضی مانند افزودن ، معمولاً معنی دارد که "همان" به معنای برابری ریاضی باشد. برای "انتخاب هر جستجو" مانند FindMinandMax ("مکان حداقل و حداکثر مقادیر ورودی" را پیدا کنید) که ممکن است بیش از یک مورد از مقادیر ورودی یکسان باشد ، تمام مکان های یک مقدار ورودی معین باید "یکسان" در نظر گرفته شوند . شما می توانید یک هسته مشابه را برای "پیدا کردن محل چپ ترین و حداکثر مقادیر ورودی" بنویسید که در آن (مثلاً) حداقل مقدار در مکان 100 بیش از حداقل مقدار یکسان در مکان 200 ترجیح داده می شود. برای این هسته ، "همان" به معنای موقعیت یکسان است ، نه صرفاً ارزش یکسان ، و توابع باتری و ترکیب کننده باید متفاوت از مواردی باشد که برای FindMinandMax وجود دارد.

• combinerName (& A , & I ) باید A ترک کند
• combinerName (& I , & A ) باید I همانند A

مثال: در هسته افزودنی ، یک مورد داده باتری به صفر می رسد. عملکرد Combiner برای این هسته علاوه بر این عمل می کند. صفر مقدار هویت برای افزودن است.

عملکرد Combiner باید قابل حمل باشد. یعنی اگر A و B موارد جمع کننده داده های اولیه توسط عملکرد اولیه سازنده باشند ، و ممکن است به عملکرد باتری صفر یا بیشتر منتقل شود ، سپس combinerName (& A , & B ) باید A مقدار مشابه combinerName (& B , & A ) تنظیم کند combinerName (& B , & A ) مجموعه های B .

مثال: در هسته Addint ، عملکرد Combiner دو مقدار مورد داده جمع کننده را اضافه می کند. علاوه بر این ، کمتری است.

عملکرد Combiner باید انجمنی باشد. این بدان معناست که اگر A ، B و C موارد داده های باتری هستند که توسط عملکرد اولیه سازنده شده اند ، و ممکن است به عملکرد باتری صفر یا بیشتر منتقل شده باشد ، سپس دو دنباله کد زیر باید A روی همان مقدار تنظیم کنند:

• combinerName(&A, &B);
  combinerName(&A, &C);

• combinerName(&B, &C);
  combinerName(&A, &B);

fMMCombiner(&A, &B)

A = minmax(A, B)

عملکرد باتری و عملکرد Combiner با هم باید از قانون اساسی تاشو پیروی کنند. یعنی اگر A و B مورد داده های باتری باشد ، A با عملکرد اولیه سازنده شده است و ممکن است به عملکرد باتری صفر یا بیشتر منتقل شده باشد ، B اولیه نشده است ، و ARG ها لیست آرگومان های ورودی و ویژه است آرگومان برای یک تماس خاص به عملکرد باتری ، سپس دو دنباله کد زیر باید A روی همان مقدار تنظیم کنید:

• accumulatorName(&A, args);  // statement 1

• initializerName(&B);        // statement 2
  accumulatorName(&B, args);  // statement 3
  combinerName(&A, &B);       // statement 4

فراخوانی هسته کاهش از کد جاوا

برای کاهش هسته به نام هسته تعریف شده در filename .rs ، سه روش در ScriptC_ filename ارائه شده است:

// Function 1
fun reduce_kernelName(ain1: Allocation, …,
                               ainN: Allocation): javaFutureType

// Function 2
fun reduce_kernelName(ain1: Allocation, …,
                               ainN: Allocation,
                               sc: Script.LaunchOptions): javaFutureType

// Function 3
fun reduce_kernelName(in1: Array<devecSiIn1Type>, …,
                               inN: Array<devecSiInNType>): javaFutureType

// Method 1
public javaFutureType reduce_kernelName(Allocation ain1, …,
                                        Allocation ainN);

// Method 2
public javaFutureType reduce_kernelName(Allocation ain1, …,
                                        Allocation ainN,
                                        Script.LaunchOptions sc);

// Method 3
public javaFutureType reduce_kernelName(devecSiIn1Type[] in1, …,
                                        devecSiInNType[] inN);

در اینجا چند نمونه از تماس با هسته افزودنی آورده شده است:

val script = ScriptC_example(renderScript)

// 1D array
//   and obtain answer immediately
val input1 = intArrayOf(…)
val sum1: Int = script.reduce_addint(input1).get()  // Method 3

// 2D allocation
//   and do some additional work before obtaining answer
val typeBuilder = Type.Builder(RS, Element.I32(RS)).apply {
    setX(…)
    setY(…)
}
val input2: Allocation = Allocation.createTyped(RS, typeBuilder.create()).also {
    populateSomehow(it) // fill in input Allocation with data
}
val result2: ScriptC_example.result_int = script.reduce_addint(input2)  // Method 1
doSomeAdditionalWork() // might run at same time as reduction
val sum2: Int = result2.get()

ScriptC_example script = new ScriptC_example(renderScript);

// 1D array
//   and obtain answer immediately
int input1[] = …;
int sum1 = script.reduce_addint(input1).get();  // Method 3

// 2D allocation
//   and do some additional work before obtaining answer
Type.Builder typeBuilder =
  new Type.Builder(RS, Element.I32(RS));
typeBuilder.setX(…);
typeBuilder.setY(…);
Allocation input2 = createTyped(RS, typeBuilder.create());
populateSomehow(input2);  // fill in input Allocation with data
ScriptC_example.result_int result2 = script.reduce_addint(input2);  // Method 1
doSomeAdditionalWork(); // might run at same time as reduction
int sum2 = result2.get();

روش 1 برای هر آرگومان ورودی در عملکرد باتری هسته یک آرگومان Allocation ورودی دارد. Renderscript Runtime بررسی می کند تا اطمینان حاصل شود که همه تخصیص ورودی دارای ابعاد یکسانی هستند و نوع Element هر یک از تخصیص ورودی با آرگومان ورودی مربوطه نمونه اولیه عملکرد جمع کننده مطابقت دارد. در صورت عدم موفقیت هر یک از این چک ها ، Renderscript یک استثنا را پرتاب می کند. هسته بیش از هر مختصات در آن ابعاد اجرا می کند.

روش 2 همان روش 1 است به جز اینکه روش 2 یک آرگومان اضافی sc را می گیرد که می تواند برای محدود کردن اجرای هسته به زیر مجموعه ای از مختصات استفاده شود.

روش 3 همان روش 1 است به جز اینکه به جای اینکه ورودی های تخصیصی را در نظر بگیرند ، ورودی های آرایه جاوا را می گیرد. این یک راحتی است که شما را از نوشتن کد برای ایجاد صریح تخصیص و کپی کردن داده ها از یک آرایه جاوا نجات می دهد. با این حال ، استفاده از روش 3 به جای روش 1 عملکرد کد را افزایش نمی دهد . برای هر آرایه ورودی ، روش 3 یک تخصیص موقت 1 بعدی با نوع Element مناسب و setAutoPadding(boolean) ایجاد می کند و آرایه را به تخصیص کپی می کند که گویی با روش copyFrom() Allocation . سپس با استفاده از آن تخصیص موقت ، روش 1 را می خواند.

توجه: اگر برنامه شما چندین تماس هسته را با همان آرایه یا با آرایه های مختلف با ابعاد مشابه و نوع عنصر انجام می دهد ، ممکن است به جای استفاده از روش 3 ، عملکرد خود را با ایجاد صریح ، جمع آوری و استفاده مجدد از تخصیص خود بهبود بخشید.

javafuturetype ، نوع بازگشت روش های کاهش منعکس شده ، یک کلاس تو در تو استاتیک منعکس شده در کلاس ScriptC_ filename است. این نشان دهنده نتیجه آینده اجرای هسته کاهش یافته است. برای به دست آوردن نتیجه واقعی اجرای ، با روش get() آن کلاس تماس بگیرید ، که مقدار نوع javaresulttype را برمی گرداند. get() همزمان است.

class ScriptC_filename(rs: RenderScript) : ScriptC(…) {
    object javaFutureType {
        fun get(): javaResultType { … }
    }
}

public class ScriptC_filename extends ScriptC {
  public static class javaFutureType {
    public javaResultType get() { … }
  }
}

JavaresultType از نتیجه عملکرد عملکرد OutConverter تعیین می شود. مگر در مواردی که ResultType یک نوع بدون امضا (مقیاس ، بردار یا آرایه) باشد ، JavaresultType نوع جاوا به طور مستقیم مربوطه است. اگر ResultType یک نوع امضا نشده است و یک نوع بزرگتر از جاوا امضا شده است ، پس JavaresultType نوع دیگری از جاوا امضا شده است. در غیر این صورت ، این نوع جاوا به طور مستقیم مربوطه است. به عنوان مثال:

• اگر نتیجه int ، int2 یا int[15] باشد ، سپس javaresulttype int ، Int2 یا int[] است. تمام مقادیر ResultType را می توان توسط JavaresultType نشان داد.
• اگر ResultType uint ، uint2 یا uint[15] باشد ، سپس javaresulttype long ، Long2 یا long[] . تمام مقادیر ResultType را می توان توسط JavaresultType نشان داد.
• اگر ResultType ulong ، ulong2 یا ulong[15] باشد ، JavaresultType long ، Long2 یا long[] . مقادیر خاصی از ResultType وجود دارد که نمی توانند توسط JavaresultType نشان داده شوند.

javafuturetype نوع نتیجه آینده است که مطابق با نتیجه عملکرد عملکرد OutConverter است.

• اگر ResultType یک نوع آرایه نباشد ، javafuturetype result_ resultType است.
• اگر ResultType آرایه ای از تعداد طول با اعضای Type Type باشد ، سپس JavafutureType resultArray Count _ memberType است.

به عنوان مثال:

class ScriptC_filename(rs: RenderScript) : ScriptC(…) {

    // for kernels with int result
    object result_int {
        fun get(): Int = …
    }

    // for kernels with int[10] result
    object resultArray10_int {
        fun get(): IntArray = …
    }

    // for kernels with int2 result
    //   note that the Kotlin type name "Int2" is not the same as the script type name "int2"
    object result_int2 {
        fun get(): Int2 = …
    }

    // for kernels with int2[10] result
    //   note that the Kotlin type name "Int2" is not the same as the script type name "int2"
    object resultArray10_int2 {
        fun get(): Array<Int2> = …
    }

    // for kernels with uint result
    //   note that the Kotlin type "long" is a wider signed type than the unsigned script type "uint"
    object result_uint {
        fun get(): Long = …
    }

    // for kernels with uint[10] result
    //   note that the Kotlin type "long" is a wider signed type than the unsigned script type "uint"
    object resultArray10_uint {
        fun get(): LongArray = …
    }

    // for kernels with uint2 result
    //   note that the Kotlin type "Long2" is a wider signed type than the unsigned script type "uint2"
    object result_uint2 {
        fun get(): Long2 = …
    }

    // for kernels with uint2[10] result
    //   note that the Kotlin type "Long2" is a wider signed type than the unsigned script type "uint2"
    object resultArray10_uint2 {
        fun get(): Array<Long2> = …
    }
}

public class ScriptC_filename extends ScriptC {
  // for kernels with int result
  public static class result_int {
    public int get() { … }
  }

  // for kernels with int[10] result
  public static class resultArray10_int {
    public int[] get() { … }
  }

  // for kernels with int2 result
  //   note that the Java type name "Int2" is not the same as the script type name "int2"
  public static class result_int2 {
    public Int2 get() { … }
  }

  // for kernels with int2[10] result
  //   note that the Java type name "Int2" is not the same as the script type name "int2"
  public static class resultArray10_int2 {
    public Int2[] get() { … }
  }

  // for kernels with uint result
  //   note that the Java type "long" is a wider signed type than the unsigned script type "uint"
  public static class result_uint {
    public long get() { … }
  }

  // for kernels with uint[10] result
  //   note that the Java type "long" is a wider signed type than the unsigned script type "uint"
  public static class resultArray10_uint {
    public long[] get() { … }
  }

  // for kernels with uint2 result
  //   note that the Java type "Long2" is a wider signed type than the unsigned script type "uint2"
  public static class result_uint2 {
    public Long2 get() { … }
  }

  // for kernels with uint2[10] result
  //   note that the Java type "Long2" is a wider signed type than the unsigned script type "uint2"
  public static class resultArray10_uint2 {
    public Long2[] get() { … }
  }
}

اگر javaresulttype یک نوع شی (از جمله نوع آرایه) باشد ، هر تماس به javaFutureType .get() در همان نمونه همان شی را برمی گرداند.

اگر javaresulttype نمی تواند تمام مقادیر نوع نتیجه را نشان دهد ، و یک هسته کاهش یک مقدار غیر قابل ارائه تولید می کند ، سپس javaFutureType .get() یک استثنا را پرتاب می کند.

روش 3 و devecsiinxtype

devecsiinxtype نوع جاوا است که مربوط به inxtype آرگومان مربوط به عملکرد باتری است. مگر اینکه Inxtype یک نوع بدون امضا یا نوع بردار باشد ، Devecsiinxtype نوع جاوا مستقیماً مربوطه است. اگر Inxtype یک نوع مقیاس بدون امضا باشد ، پس از آن Devecsiinxtype نوع جاوا است که مستقیماً با نوع مقیاس امضا شده با همان اندازه مطابقت دارد. اگر inxtype یک نوع بردار امضا شده است ، سپس devecsiinxtype نوع جاوا است که مستقیماً مطابق با نوع جزء بردار است. اگر inxtype یک نوع بردار بدون امضا است ، سپس devecsiinxtype نوع جاوا است که به طور مستقیم با نوع مقیاس امضا شده با اندازه یک نوع جزء بردار مطابقت دارد. به عنوان مثال:

• اگر inxtype int باشد ، پس از آن devecsiinxtype int است.
• اگر inxtype int2 باشد ، پس از آن devecsiinxtype int است. آرایه یک نمایش مسطح است: دو برابر عناصر مقیاس پذیر است زیرا تخصیص دارای عناصر بردار 2 جزء است. این به همان روشی است که روشهای copyFrom() برای Allocation کار می کنند.
• اگر inxtype uint باشد ، سپس دستگاه های inxtype int است. یک مقدار امضا شده در آرایه جاوا به عنوان یک مقدار امضا نشده از همان بیت پاتر در تخصیص تعبیر می شود. این به همان روشی است که روشهای copyFrom() برای Allocation کار می کنند.
• اگر inxtype uint2 باشد ، سپس دستگاه های inxtype int است. این ترکیبی از نحوه برخورد با int2 و uint است: آرایه یک نمایش مسطح است و مقادیر امضا شده آرایه جاوا به عنوان مقادیر عناصر امضا نشده Renderscript تعبیر می شوند.

توجه داشته باشید که برای روش 3 ، انواع ورودی متفاوت از انواع نتیجه انجام می شود:

• ورودی بردار اسکریپت در سمت جاوا مسطح می شود ، در حالی که نتیجه بردار اسکریپت اینگونه نیست.
• ورودی بدون امضا اسکریپت به عنوان یک ورودی امضا شده با همان اندازه در سمت جاوا نشان داده شده است ، در حالی که نتیجه امضا نشده یک اسکریپت به عنوان یک نوع امضا شده گسترده در سمت جاوا (به جز در مورد ulong ) نشان داده شده است.

هسته های کاهش بیشتر هسته

#pragma rs reduce(dotProduct) \
  accumulator(dotProductAccum) combiner(dotProductSum)

// Note: No initializer function -- therefore,
// each accumulator data item is implicitly initialized to 0.0f.

static void dotProductAccum(float *accum, float in1, float in2) {
  *accum += in1*in2;
}

// combiner function
static void dotProductSum(float *accum, const float *val) {
  *accum += *val;
}

// Find a zero Element in a 2D allocation; return (-1, -1) if none
#pragma rs reduce(fz2) \
  initializer(fz2Init) \
  accumulator(fz2Accum) combiner(fz2Combine)

static void fz2Init(int2 *accum) { accum->x = accum->y = -1; }

static void fz2Accum(int2 *accum,
                     int inVal,
                     int x /* special arg */,
                     int y /* special arg */) {
  if (inVal==0) {
    accum->x = x;
    accum->y = y;
  }
}

static void fz2Combine(int2 *accum, const int2 *accum2) {
  if (accum2->x >= 0) *accum = *accum2;
}

// Note that this kernel returns an array to Java
#pragma rs reduce(histogram) \
  accumulator(hsgAccum) combiner(hsgCombine)

#define BUCKETS 256
typedef uint32_t Histogram[BUCKETS];

// Note: No initializer function --
// therefore, each bucket is implicitly initialized to 0.

static void hsgAccum(Histogram *h, uchar in) { ++(*h)[in]; }

static void hsgCombine(Histogram *accum,
                       const Histogram *addend) {
  for (int i = 0; i < BUCKETS; ++i)
    (*accum)[i] += (*addend)[i];
}

// Determines the mode (most frequently occurring value), and returns
// the value and the frequency.
//
// If multiple values have the same highest frequency, returns the lowest
// of those values.
//
// Shares functions with the histogram reduction kernel.
#pragma rs reduce(mode) \
  accumulator(hsgAccum) combiner(hsgCombine) \
  outconverter(modeOutConvert)

static void modeOutConvert(int2 *result, const Histogram *h) {
  uint32_t mode = 0;
  for (int i = 1; i < BUCKETS; ++i)
    if ((*h)[i] > (*h)[mode]) mode = i;
  result->x = mode;
  result->y = (*h)[mode];
}

نمونه کد اضافی

نمونه های BasicRenderscript ، RenderscriptIntrinsic و Hello Compute بیشتر استفاده از API های تحت پوشش در این صفحه را نشان می دهد.