Bu sayfa, Cloud Translation API ile çevrilmiştir.

RenderScript'e Genel Bakış

RenderScript, işlem bakımından yoğun görevleri Android'de yüksek performansta çalıştırmak için geliştirilmiş bir çerçevedir. RenderScript, öncelikli olarak veriye paralel hesaplamaya yönelik olarak tasarlanmıştır ancak seri iş yükleri de faydalı olabilir. RenderScript çalışma zamanı, çok çekirdekli CPU'lar ve GPU'lar gibi cihazlarda kullanılabilen işlemcilerde çalışmayı paralel hale getirir. Böylece işleri planlamak yerine algoritmaları ifade etmeye odaklanabilirsiniz. RenderScript özellikle resim işleme, sayısal fotoğrafçılık veya bilgisayar görüşü işlemleri yapan uygulamalar için kullanışlıdır.

RenderScript'i kullanmaya başlamak için anlamanız gereken iki temel kavram vardır:

Dil, yüksek performanslı bilgi işlem kodu yazmak için C99 ile türetilmiş bir dildir. RenderScript Kernel yazma, bu programın çekirdeklerini yazmak için nasıl kullanılacağını açıklar.
control API, RenderScript kaynaklarının ömrünü yönetmek ve çekirdek yürütmeyi kontrol etmek için kullanılır. Üç farklı dilde kullanılabilir: Java, Android NDK'da C++ ve C99 ile türetilen çekirdek dilinin kendisi. Java Code'dan RenderScript'i kullanma ve Single-Source RenderScript'te sırasıyla birinci ve üçüncü seçenekleri açıklar.

RenderScript Çekirdeği Yazma

RenderScript çekirdeği genellikle <project_root>/src/rs dizinindeki bir .rs dosyasında bulunur; her .rs dosyası komut dosyası olarak adlandırılır. Her komut dosyası kendi çekirdek, işlev ve değişken grubunu içerir. Bir komut dosyası şunları içerebilir:

Bu komut dosyasında kullanılan RenderScript çekirdek dilinin sürümünü tanımlayan bir pragma bildirimi (#pragma version(1)). Şu anda geçerli tek değer 1'dir.
Bu komut dosyasında yansıtılan Java sınıflarının paket adını tanımlayan bir pragma bildirimi (#pragma rs java_package_name(com.example.app)). .rs dosyanızın, bir kitaplık projesinde değil, uygulama paketinizin bir parçası olması gerektiğini unutmayın.
Çağırılabilir işlev yok veya hiç yok. Çağırılabilir işlev, rastgele bağımsız değişkenlerle Java kodunuzdan çağırabileceğiniz tek iş parçacıklı bir RenderScript işlevidir. Bunlar genellikle daha büyük bir işleme ardışık düzeninde ilk kurulum veya seri hesaplamalar için kullanışlıdır.
Sıfır veya daha fazla komut dosyası global. Genel komut dosyası, C'deki genel değişkene benzer. Komut dosyası genellerine Java kodundan erişebilirsiniz. Bunlar genellikle RenderScript çekirdeklerine parametre iletmek için kullanılır. Komut dosyası genel şartları burada daha ayrıntılı olarak açıklanmıştır.
Sıfır veya daha fazla işlem çekirdeği. İşlem çekirdeği, RenderScript çalışma zamanını bir veri koleksiyonunda paralel olarak yürütülmesi için yönlendirebileceğiniz bir işlev veya işlev koleksiyonudur. İki tür işlem çekirdek vardır: eşleme çekirdekleri (foreach çekirdekler olarak da adlandırılır) ve azaltma çekirdekleri.

Eşleme çekirdeği, aynı boyutlara sahip Allocations koleksiyonu üzerinde çalışan paralel bir işlevdir. Varsayılan olarak, bu boyutlardaki her koordinat için bir kez yürütülür. Genellikle (ancak özel olarak değil) Allocations giriş koleksiyonunu her defasında bir Element olacak şekilde Allocation çıkışına dönüştürmek için kullanılır.
- Basit bir eşleme çekirdeği örneğini burada bulabilirsiniz:
```
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;
}
```
  Bu işlev, çoğu açıdan standart C işleviyle aynıdır. İşlev prototipine uygulanan RS_KERNEL özelliği, işlevin çağrılabilir bir işlev yerine RenderScript eşleme çekirdeği olduğunu belirtir. in bağımsız değişkeni, çekirdek başlatma işlemine iletilen Allocation girişine göre otomatik olarak doldurulur. x ve y bağımsız değişkenleri aşağıda açıklanmıştır. Çekirdekten döndürülen değer, Allocation çıkışında uygun konuma otomatik olarak yazılır. Varsayılan olarak bu çekirdek, Allocation içindeki Element başına çekirdek işlevi bir yürütme ile Allocation girişinin tamamında çalıştırılır.
  
  Bir eşleme çekirdeğinde bir veya daha fazla giriş Allocations, tek bir Allocation çıkışı ya da her ikisi bulunabilir. RenderScript çalışma zamanı, tüm giriş ve çıkış Ayırmalarının aynı boyutlara sahip olduğundan ve Element türlerindeki giriş ve çıkış Ayırma türlerinin çekirdeğin prototipiyle eşleştiğinden emin olur. Bu kontrollerden biri başarısız olursa RenderScript bir istisna oluşturur.
  
  NOT: Android 6.0'dan (API düzeyi 23) önce, bir eşleme çekirdeğinin birden fazla girişi Allocation olamaz.
  
  Çekirdeğin sahip olduğundan daha fazla giriş veya çıkış Allocations değerine ihtiyacınız varsa bu nesneler rs_allocation komut dosyası genellerine bağlı olmalı ve rsGetElementAt_type() ya da rsSetElementAt_type() aracılığıyla bir çekirdekten veya çağrılabilir işlevden erişilmelidir.
  
  NOT: RS_KERNEL, size kolaylık sağlamak için RenderScript tarafından otomatik olarak tanımlanan bir makrodur:
```
#define RS_KERNEL __attribute__((kernel))
```
Azaltma çekirdeği, aynı boyutlardaki bir Allocations girdi koleksiyonu üzerinde çalışan bir işlev ailesidir. Varsayılan olarak, toplayıcı işlevi bu boyutlardaki her koordinat için bir kez yürütülür. Genellikle (ancak özel olarak değil) bir Allocations giriş koleksiyonunu tek bir değere "azaltmak" için kullanılır.
- Girişin Elements değerini toplayan basit bir azaltma çekirdeği örneğini aşağıda görebilirsiniz:
```
#pragma rs reduce(addint) accumulator(addintAccum)

static void addintAccum(int *accum, int val) {
  *accum += val;
}
```
  Kısaltma çekirdeği, kullanıcı tarafından yazılmış bir veya daha fazla işlevden oluşur. #pragma rs reduce, çekirdeğin adını (bu örnekte addint) ve çekirdeği oluşturan işlevlerin adlarını ve rollerini (bu örnekte accumulator işlevi addintAccum) belirterek tanımlamak için kullanılır. Bu tür işlevlerin tümü static olmalıdır. Azaltma çekirdeği her zaman bir accumulator işlevi gerektirir; çekirdeğin ne yapmasını istediğinize bağlı olarak başka işlevleri de olabilir.
  
  Bir azaltma çekirdek toplayıcı işlevi void döndürmeli ve en az iki bağımsız değişkene sahip olmalıdır. İlk bağımsız değişken (bu örnekte accum) bir toplayıcı veri öğesine işaret eder. İkinci bağımsız değişken (bu örnekte val), çekirdek başlatma işlemine iletilen girişe göre (Allocation) otomatik olarak doldurulur. Toplayıcı veri öğesi, RenderScript çalışma zamanı tarafından oluşturulur; varsayılan olarak sıfıra başlatılır. Varsayılan olarak bu çekirdek, Allocation içindeki Element başına toplayıcı işlevi bir kez yürütülerek Allocation girişinin tamamında çalıştırılır. Varsayılan olarak, toplayıcı veri öğesinin son değeri azaltma işleminin sonucu olarak değerlendirilir ve Java'ya döndürülür. RenderScript çalışma zamanı, giriş Ayırma türünün Element türünün toplayıcı işlevinin prototipiyle eşleştiğinden emin olmak için kontrol eder. Eşleşmezse RenderScript bir istisna oluşturur.
  
  Azaltma çekirdeğinin bir veya daha fazla girişi Allocations vardır, ancak Allocations çıkışı yoktur.
  
  Azaltma çekirdekleriyle ilgili daha ayrıntılı bilgiyi burada bulabilirsiniz.
  
  Azaltma çekirdekleri, Android 7.0 (API düzeyi 24) ve sonraki sürümlerde desteklenir.
Bir eşleme çekirdek işlevi veya bir azaltma çekirdeği toplayıcı işlevi, int veya uint32_t türünde olması gereken özel bağımsız değişkenleri x, y ve z kullanarak mevcut yürütmenin koordinatlarına erişebilir. Bu bağımsız değişkenler isteğe bağlıdır.

Bir eşleme çekirdek işlevi veya bir azaltma çekirdek toplayıcı işlevi de rs_kernel_context türündeki isteğe bağlı özel context bağımsız değişkenini alabilir. Mevcut yürütme işleminin belirli özelliklerini sorgulamak için kullanılan bir çalışma zamanı API'leri ailesi için gereklidir (örneğin, rsGetDimX). (context bağımsız değişkeni, Android 6.0 (API düzeyi 23) ve sonraki sürümlerde kullanılabilir.)
İsteğe bağlı bir init() işlevi. init() işlevi, komut dosyası ilk kez örneklendiğinde RenderScript'in çalıştırdığı özel bir çağrılabilir işlev türüdür. Bu, komut dosyası oluşturulurken otomatik olarak bazı hesaplamaların yapılmasına olanak tanır.
Sıfır veya daha fazla statik komut dosyası genel ve işlevi. Statik bir global komut dosyası, Java kodundan erişilememesi dışında global komut dosyasına eşdeğerdir. Statik işlev, komut dosyasındaki herhangi bir çekirdekten veya çağrılabilir işlevden çağrılabilen ancak Java API'ye sunulmayan standart bir C işlevidir. Global veya işleve Java kodundan erişilmesi gerekmiyorsa bu komut dosyasının static olarak tanımlanmasını önemle tavsiye ederiz.

Kayan nokta hassasiyeti ayarlanıyor

Bir komut dosyasında gereken kayan nokta hassasiyet düzeyini kontrol edebilirsiniz. Bu özellik, tam IEEE 754-2008 standardı (varsayılan olarak kullanılır) gerekli olmadığında yararlı olur. Aşağıdaki pragma'lar farklı bir kayan nokta hassasiyeti düzeyi ayarlayabilir:

#pragma rs_fp_full (hiçbir şey belirtilmezse varsayılan): IEEE 754-2008 standardında belirtildiği şekilde kayan nokta hassasiyeti gerektiren uygulamalar içindir.
#pragma rs_fp_relaxed: Katı IEEE 754-2008 uyumluluğu gerektirmeyen ve daha düşük hassasiyeti tolere edebilen uygulamalar için. Bu mod, dövmeler için boşaltmayı sıfıra ve sıfıra yuvarlamayı etkinleştirir.
#pragma rs_fp_imprecise: Katı hassasiyet koşulları olmayan uygulamalar için. Bu mod, rs_fp_relaxed öğesinde aşağıdakilerin yanı sıra her şeyi etkinleştirir:
- -0,0 ile sonuçlanan işlemler +0,0 sonucunu döndürebilir.
- INF ve NAN işlemleri tanımlanmamış.

Çoğu uygulamada rs_fp_relaxed, herhangi bir yan etki olmadan kullanılabilir. Bu, yalnızca esnek hassasiyetle kullanılabilen ek optimizasyonlar (SIMD CPU talimatları gibi) nedeniyle bazı mimarilerde çok faydalı olabilir.

Java'dan RenderScript API'lerine erişme

RenderScript kullanan bir Android uygulaması geliştirirken şu iki yöntemden biriyle Java'dan API'ye erişebilirsiniz:

android.renderscript - Bu sınıf paketindeki API'ler Android 3.0 (API düzeyi 11) ve sonraki sürümleri çalıştıran cihazlarda kullanılabilir.
android.support.v8.renderscript - Bu paketteki API'ler, Android 2.3 (API düzeyi 9) ve sonraki sürümleri çalıştıran cihazlarda kullanmanıza olanak tanıyan Destek Kitaplığı üzerinden sunulur.

Bu işlemin artıları ve eksileri:

Destek Kitaplığı API'lerini kullanırsanız, uygulamanızın RenderScript bölümü, hangi RenderScript özelliklerini kullandığınızdan bağımsız olarak Android 2.3 (API düzeyi 9) ve sonraki sürümleri çalıştıran cihazlarla uyumlu olur. Böylece, uygulamanız yerel (android.renderscript) API'lere kıyasla daha fazla cihazda çalışır.
Belirli RenderScript özellikleri Destek Kitaplığı API'ları üzerinden kullanılamaz.
Destek Kitaplığı API'lerini kullanırsanız yerel (android.renderscript) API'lerine kıyasla (muhtemelen önemli ölçüde) daha büyük APK'lara sahip olursunuz.

RenderScript Destek Kitaplığı API'larını kullanma

Destek Kitaplığı RenderScript API'lerini kullanmak için geliştirme ortamınızı bu API'lere erişecek şekilde yapılandırmanız gerekir. Bu API'leri kullanmak için aşağıdaki Android SDK araçları gereklidir:

Android SDK Tools düzeltmesi 22.2 veya sonraki sürümler
Android SDK Derleme Araçları düzeltmesi 18.1.0 veya sonraki sürümler

Android SDK Derleme Araçları 24.0.0 sürümünden itibaren Android 2.2 (API düzeyi 8) artık desteklenmemektedir.

Bu araçların yüklü sürümünü Android SDK Yöneticisi'nden kontrol edip güncelleyebilirsiniz.

Destek Kitaplığı RenderScript API'larını kullanmak için:

Gerekli Android SDK sürümünün yüklü olduğundan emin olun.
Android derleme işleminin ayarlarını RenderScript ayarlarını içerecek şekilde güncelleyin:
- Uygulama modülünüzün uygulama klasöründeki build.gradle dosyasını açın.
- Aşağıdaki RenderScript ayarlarını dosyaya ekleyin:
  Eskitme
  
  android { compileSdkVersion 33 defaultConfig { minSdkVersion 9 targetSdkVersion 19 renderscriptTargetApi 18 renderscriptSupportModeEnabled true } }
  Kotlin
  
  android { compileSdkVersion(33) defaultConfig { minSdkVersion(9) targetSdkVersion(19) renderscriptTargetApi = 18 renderscriptSupportModeEnabled = true } }
  Yukarıda listelenen ayarlar, Android derleme işlemindeki belirli davranışları kontrol eder:
  - renderscriptTargetApi - Oluşturulacak bayt kodu sürümünü belirtir. Bu değeri, kullandığınız tüm işlevleri sağlayabilecek en düşük API seviyesine ve renderscriptSupportModeEnabled öğesini true olarak ayarlamanızı öneririz. Bu ayar için geçerli değerler, 11 ile en son yayınlanan API düzeyi arasındaki herhangi bir tam sayı değeridir. Uygulama manifestinizde belirtilen minimum SDK sürümünüz farklı bir değere ayarlanırsa bu değer yoksayılır ve derleme dosyasındaki hedef değer, minimum SDK sürümünü ayarlamak için kullanılır.
  - renderscriptSupportModeEnabled - Çalıştığı cihaz hedef sürümü desteklemiyorsa oluşturulan bayt kodunun uyumlu sürüme yedeklenmesi gerektiğini belirtir.
RenderScript kullanan uygulama sınıflarınızda, Destek Kitaplığı sınıfları için bir içe aktarma ekleyin:
Kotlin
```
import android.support.v8.renderscript.*
```
Java
```
import android.support.v8.renderscript.*;
```

Java veya Kotlin Kodu'ndan RenderScript'i kullanma

Java veya Kotlin kodundan RenderScript'in kullanılması, android.renderscript ya da android.support.v8.renderscript paketinde bulunan API sınıflarına bağlıdır. Çoğu uygulama aynı temel kullanım kalıbını izler:

Bir RenderScript bağlamını başlatın. create(Context) ile oluşturulan RenderScript bağlamı, RenderScript'in kullanılabilmesini sağlar ve sonraki tüm RenderScript nesnelerinin ömrünü kontrol etmek için bir nesne sağlar. Bağlam oluşturmayı, farklı donanım parçalarında kaynak oluşturabileceğinden ve mümkünse bir uygulamanın kritik yolunda olmamalıdır. Genellikle, bir uygulama aynı anda yalnızca tek bir RenderScript bağlamına sahip olur.
Komut dosyasına geçirilecek en az bir Allocation oluşturun. Allocation, sabit miktarda veri için depolama alanı sağlayan bir RenderScript nesnesidir. Komut dosyalarındaki çekirdekler, giriş ve çıkış olarak Allocation nesnelerini alır ve komut dosyası genelleri olarak bağlandığında çekirdeklerdeki Allocation nesnelerine rsGetElementAt_type() ve rsSetElementAt_type() kullanılarak erişilebilir. Allocation nesneleri, dizilerin Java kodundan RenderScript koduna ve bunun tersi de geçerlidir. Allocation nesneleri genellikle createTyped() veya createFromBitmap() kullanılarak oluşturulur.
Gerekli komut dosyalarını oluşturun. RenderScript'i kullanırken iki tür komut dosyası kullanabilirsiniz:
- ScriptC: Bunlar, yukarıdaki RenderScript Kernel oluşturma bölümünde açıklandığı gibi kullanıcı tanımlı komut dosyalarıdır. Java kodundan komut dosyasına erişimi kolaylaştırmak için her komut dosyasının, RenderScript derleyicisi tarafından yansıtılan bir Java sınıfı vardır. Bu sınıfın adı ScriptC_filename vardır. Örneğin, yukarıdaki eşleme çekirdeği invert.rs konumundaysa ve bir RenderScript bağlamı zaten mRenderScript konumundaysa komut dosyasını örneklendirmek için Java veya Kotlin kodu şöyle olur:
  Kotlin
  
  val invert = ScriptC_invert(renderScript)
  Java
  
  ScriptC_invert invert = new ScriptC_invert(renderScript);
- ScriptIntrinsic: Bunlar, Gauss bulanıklığı, konvolüsyon ve görüntü harmanlama gibi yaygın işlemler için yerleşik RenderScript çekirdekleridir. Daha fazla bilgi için ScriptIntrinsic alt sınıflarını inceleyin.
Atamaları verilerle doldurun. createFromBitmap() ile oluşturulan Ayırmalar hariç, bir Ayırma ilk oluşturulduğunda boş verilerle doldurulur. Bir Ayırmayı doldurmak için Allocation sayfasındaki "kopyalama" yöntemlerinden birini kullanın. "Kopyalama" yöntemleri eşzamanlıdır.
Gerekli tüm komut dosyası genellerini belirleyin. set_globalname adlı aynı ScriptC_filename sınıfındaki yöntemleri kullanarak global ayarlar yapabilirsiniz. Örneğin, threshold adlı bir int değişkeni ayarlamak için set_threshold(int) Java yöntemini, lookup adlı bir rs_allocation değişkeni ayarlamak için de set_lookup(Allocation) Java yöntemini kullanın. set yöntemleri eşzamansızdır.
Uygun çekirdekleri ve çağrılabilir işlevleri başlatın.
Belirli bir çekirdeği başlatma yöntemleri, forEach_mappingKernelName() veya reduce_reductionKernelName() adlı yöntemlerle aynı ScriptC_filename sınıfında yansıtılır. Bu lansmanlar eşzamansızdır. Çekirdekteki bağımsız değişkenlere bağlı olarak yöntem, her biri aynı boyutlara sahip olması gereken bir veya daha fazla Ayırma alır. Varsayılan olarak, bir çekirdek bu boyutlardaki her koordinat üzerinde yürütülür. Bu koordinatların bir alt kümesi üzerinde bir çekirdeği yürütmek için forEach veya reduce yöntemine son bağımsız değişken olarak uygun bir Script.LaunchOptions iletin.

Aynı ScriptC_filename sınıfında açıklanan invoke_functionName yöntemlerini kullanarak çağrılabilir işlevleri başlatın. Bu lansmanlar eşzamansızdır.
Allocation nesnelerden ve javaFutureType nesnelerinden veri alın. Allocation dosyasındaki verilere Java kodundan erişmek için Allocation dosyasındaki "kopyalama" yöntemlerinden birini kullanarak bu verileri Java'ya geri kopyalamanız gerekir. İndirme çekirdeğinin sonucunu elde etmek için javaFutureType.get() yöntemini kullanmanız gerekir. "Kopyala" ve get() yöntemleri eşzamanlıdır.
RenderScript bağlamını kaldırın. RenderScript bağlamını destroy() ile veya RenderScript bağlam nesnesinin çöp toplama yapmasına izin vererek kaldırabilirsiniz. Bu, söz konusu bağlama ait herhangi bir nesnenin ileride istisna olarak kullanılmasına neden olur.

Eşzamansız yürütme modeli

Yansıtılan forEach, invoke, reduce ve set yöntemleri eşzamansızdır. Her biri, istenen işlemi tamamlamadan önce Java'ya geri dönebilir. Ancak, her bir işlem başlatılma sırasına göre serileştirilir.

Allocation sınıfı, Ayırmalar'a ve Tahsislerden veri kopyalamak için "kopyalama" yöntemleri sunar. "Kopyala" yöntemi eşzamanlıdır ve aynı Ayırma'ya dokunan yukarıdaki eşzamansız işlemlere göre serileştirilir.

Yansıtılan javaFutureType sınıfları, azaltma sonucunu almak için bir get() yöntemi sağlar. get() eşzamanlıdır ve azaltmaya (eşzamansız olan) göre serileştirilir.

Tek Kaynaklı RenderScript

Android 7.0 (API düzeyi 24), çekirdeklerin Java yerine tanımlandıkları komut dosyasından başlatıldığı Single-Source RenderScript adlı yeni bir programlama özelliğini kullanıma sunar. Bu yaklaşım şu anda, bu bölümde kısa ve öz olması amacıyla sadece "çekirdekler" olarak adlandırılan çekirdeklerin eşlenmesiyle sınırlıdır. Bu yeni özellik, komut dosyasının içinden rs_allocation türünde ayırmalar oluşturmayı da destekler. Birden fazla çekirdek başlatma gerekli olsa bile, artık bir algoritmanın tamamını yalnızca bir komut dosyası içinde uygulamak mümkündür. İki açıdan avantaj vardır: Kod daha okunabilir bir kod şeklindedir, çünkü bir algoritmanın tek bir dilde uygulanmasını sağlar ve birden fazla çekirdek başlatmada Java ile RenderScript arasındaki daha az geçiş nedeniyle potansiyel olarak daha hızlı kod verir.

Tek Kaynaklı RenderScript'te çekirdekleri RenderScript Kernelleri Yazma konusunda açıklandığı gibi yazarsınız. Daha sonra, başlatmak için rsForEach() çağıran bir çağrılabilir işlev yazıyorsunuz. Bu API, ilk parametre olarak bir çekirdek işlevi alır ve ardından giriş ve çıkış ayırmaları gelir. Benzer bir API rsForEachWithOptions(), çekirdek işlevinin işlemesi için giriş ve çıkış ayırmalarındaki öğelerin bir alt kümesini belirten rs_script_call_t türünde ek bir bağımsız değişken alır.

RenderScript hesaplamasını başlatmak için çağrılabilir işlevi Java'dan çağırırsınız. RenderScript'i Java Code'dan kullanma bölümündeki adımları uygulayın. Uygun çekirdekleri başlatma adımında, invoke_function_name() kullanarak çağrılabilir işlevi çağırın. Bu işlem, çekirdeklerin başlatılması dahil olmak üzere tüm hesaplamayı başlatır.

Ayırma işlemleri genellikle bir çekirdek lansmanından diğerine ara sonuçları kaydetmek ve aktarmak için gereklidir. Bunları rsCreateAllocation() kullanarak oluşturabilirsiniz. Bu API'nin kullanımı kolay bir biçimi rsCreateAllocation_<T><W>(…)'dir. Burada T bir öğenin veri türünü, W ise öğenin vektör genişliğidir. API, X, Y ve Z boyutlarındaki boyutları bağımsız değişken olarak alır. 1D veya 2D ayırmalarda Y veya Z boyutu atlanabilir. Örneğin rsCreateAllocation_uchar4(16384), her biri uchar4 türünde olan 16384 öğenin 1D olarak ayrılmasını oluşturur.

Ayırma işlemleri sistem tarafından otomatik olarak yönetilir. Bunları açıkça yayınlamanız veya serbest bırakmanız gerekmez. Ancak temel ayırma için herkese açık kullanıcı adına artık ihtiyacınız olmadığını belirtmek üzere rsClearObject(rs_allocation* alloc) kodunu çağırabilirsiniz. alloc Böylece sistem, kaynakları olabildiğince erken boşaltabilir.

RenderScript Kernel yazma bölümü, bir görüntüyü ters çeviren örnek bir çekirdek içerir. Aşağıdaki örnekte, Tek Kaynaklı RenderScript kullanılarak bir resme birden fazla efekt uygulamak için bu işlev genişletilmektedir. Bu çekirdek, renkli bir resmi siyah beyaza dönüştüren greyscale adlı başka bir çekirdek içerir. Çağırılabilir process() işlevi, bu iki çekirdeği art arda bir giriş görüntüsüne uygular ve bir çıkış görüntüsü üretir. Hem giriş hem de çıkış için ayırmalar, rs_allocation türündeki bağımsız değişkenler olarak aktarılır.

// 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() işlevini Java veya Kotlin'den aşağıdaki gibi çağırabilirsiniz:

Kotlin

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)

Java

// 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);

Bu örnekte, iki çekirdek başlatma içeren bir algoritmanın, RenderScript dilinin kendisinde nasıl tamamen uygulanabileceği gösterilmektedir. Tek Kaynaklı RenderScript kullanılmadığında, her iki çekirdeği Java kodundan başlatmanız, çekirdek başlatma işlemlerini çekirdek tanımlarından ayırmanız ve algoritmanın tamamının anlaşılmasını zorlaştırmanız gerekir. Tek Kaynaklı RenderScript kodunun okunması daha kolay olmasının yanı sıra çekirdek başlatma işlemlerinde Java ile komut dosyası arasındaki geçişi de ortadan kaldırır. Bazı yinelemeli algoritmalar, çekirdekleri yüzlerce kez başlatabilir. Bu da bu tür geçişlerin ek yükünü önemli ölçüde artırır.

Komut Dosyası Global'lar

Komut dosyası global, bir komut dosyası (.rs) dosyasında static olmayan normal bir genel değişkendir. filename.rs dosyasında tanımlanan var adlı global bir komut dosyası için ScriptC_filename sınıfına yansıtılan bir get_var yöntemi olacaktır. Genel const olmadığı sürece set_var yöntemi de olur.

Belirli bir global komut dosyasının iki ayrı değeri vardır: Java değeri ve script değeri. Bu değerler aşağıdaki gibi davranır:

var komut dosyasında statik bir başlatıcı varsa bu işlev, hem Java hem de komut dosyasında var ilk değerini belirtir. Aksi takdirde, bu başlangıç değeri sıfır olur.
Komut dosyası içindeki var öğesine, komut dosyası değerini okuyup yazar.
get_var yöntemi Java değerini okur.
set_var yöntemi (varsa) Java değerini hemen ve komut dosyası değerini eşzamansız olarak yazar.

NOT: Bu, komut dosyasındaki herhangi bir statik başlatıcı hariç olmak üzere, komut dosyasının içinden global bir dosyaya yazılan değerlerin Java tarafından görülmeyeceği anlamına gelir.

Derinliği Azaltma

Azaltma, bir veri koleksiyonunu tek bir değer altında birleştirme işlemidir. Bu, paralel programlamada aşağıdakiler gibi uygulamalarda yararlı bir temel öğedir:

tüm veriler üzerinden toplamı veya çarpımı hesaplayarak
mantıksal işlemleri (and, or, xor) hesaplama
verilerdeki minimum veya maksimum değeri bulma
belirli bir değeri arama veya veriler içindeki belirli bir değerin koordinatı için arama yapma

RenderScript, Android 7.0 (API düzeyi 24) ve sonraki sürümlerde kullanıcı tarafından yazılan azaltma algoritmalarının etkin olmasını sağlamak için azaltma çekirdeklerini destekler. 1, 2 veya 3 boyutlu girişlerde azaltma çekirdeklerini başlatabilirsiniz.

Yukarıdaki bir örnekte basit bir addint azaltma çekirdeği gösterilmektedir. Aşağıda, 1 boyutlu bir Allocation'da minimum ve maksimum long değerlerinin konumlarını bulan daha karmaşık bir findMinAndMax azaltma çekirdeği verilmiştir:

#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;
}

NOT: Kısaltma çekirdekleri için burada daha fazla örnek bulabilirsiniz.

RenderScript çalışma zamanı, bir azaltma çekirdeğini çalıştırmak için kısaltma işleminin durumunu tutmak üzere toplayıcı veri öğeleri adı verilen bir veya daha fazla değişken oluşturur. RenderScript çalışma zamanı, performansı en üst düzeye çıkaracak şekilde toplayıcı veri öğelerinin sayısını seçer. Toplayıcı veri öğelerinin türü (accumType), çekirdeğin toplayıcı işlevi tarafından belirlenir. Bu işlevin ilk bağımsız değişkeni, bir toplayıcı veri öğesine işaret eder. Varsayılan olarak her toplayıcı veri öğesi sıfır olarak başlatılır (ör. memset). Ancak farklı bir şey yapmak için bir başlatma işlevi yazabilirsiniz.

Örnek: addint çekirdeğinde, giriş değerlerini toplamak için toplayıcı verisi öğeleri (int türünde) kullanılır. Başlatıcı işlevi olmadığından her toplayıcı veri öğesi sıfır olarak başlatılır.

Örnek: findMinAndMax çekirdeğinde, şimdiye kadar bulunan minimum ve maksimum değerleri izlemek için toplayıcı verisi öğeleri (MinAndMax türündeki) kullanılır. Bunları sırasıyla LONG_MAX ve LONG_MIN olarak ayarlamak ve bu değerlerin konumlarını -1 olarak ayarlamak için bir başlatıcı işlevi vardır. Bu, değerlerin işlenen girişin (boş) bölümünde aslında mevcut olmadığını gösterir.

RenderScript, girişlerdeki her koordinat için toplayıcı işlevinizi bir kez çağırır. Tipik olarak işleviniz, toplayıcı veri öğesini girişe göre bir şekilde güncellemelidir.

Örnek: addint çekirdeğinde, toplayıcı işlevi bir giriş Öğesinin değerini toplayıcı veri öğesine ekler.

Örnek: findMinAndMax çekirdeğinde toplayıcı işlevi, giriş Öğesi değerinin toplayıcı veri öğesinde kaydedilen minimum değerden düşük veya bu değere eşit olup olmadığını ve/veya toplayıcı veri öğesinde kaydedilen maksimum değerden büyük ya da buna eşit olup olmadığını kontrol eder ve toplayıcı veri öğesini uygun şekilde günceller.

Toplayıcı işlevi, girişlerdeki her koordinat için bir kez çağrıldıktan sonra RenderScript'in toplayıcı veri öğelerini tek bir toplayıcı veri öğesinde birleştirmesi gerekir. Bunu yapmak için bir birleştirici işlevi yazabilirsiniz. Toplayıcı işlevinde tek bir giriş varsa ve özel bağımsız değişkenler yoksa bir birleştirici işlevi yazmanız gerekmez. RenderScript, toplayıcı veri öğelerini birleştirmek için toplayıcı işlevini kullanır. (Bu varsayılan davranış istediğiniz gibi değilse yine de bir birleştirici işlevi yazabilirsiniz.)

Örnek: addint çekirdeğinde birleştirici işlevi olmadığından toplayıcı işlevi kullanılır. Bu doğru bir davranıştır, çünkü bir değer koleksiyonunu iki parçaya bölersek ve bu iki parçadaki değerleri ayrı ayrı toplarsak bu iki toplamı toplamak tüm koleksiyonu toplamakla aynı olur.

Örnek: findMinAndMax çekirdeğinde birleştirici işlevi, *val "kaynak" toplayıcı veri öğesinde kaydedilen minimum değerin "hedef" toplayıcı veri öğesinde *accum kaydedilen minimum değerden düşük olup olmadığını kontrol eder ve uygun şekilde *accum günceller. Maksimum değer için benzer bir işlem yapar. Bu işlem, *accum giriş değerlerinin tamamı *accum yerine *accum, kısmı da *val konumunda toplanması durumunda olacağı durumu günceller.

Toplayıcı veri öğelerinin tümü birleştirildikten sonra, RenderScript, Java'ya dönmek için azaltma sonucunu belirler. Bunu yapmak için bir dış dönüştürücü işlevi yazabilirsiniz. Birleştirilmiş toplayıcı veri öğelerinin nihai değerinin indirgenmenin sonucu olmasını istiyorsanız dış dönüştürücü işlevi yazmanıza gerek yoktur.

Örnek: addint çekirdeğinde dış dönüştürücü işlevi yoktur. Birleştirilmiş veri öğelerinin son değeri, girdinin tüm Öğelerinin toplamıdır. Bu, döndürmek istediğimiz değerdir.

Örnek: findMinAndMax çekirdeğinde, dış dönüştürücü işlevi, tüm toplayıcı veri öğelerinin kombinasyonundan kaynaklanan minimum ve maksimum değerlerin konumlarını tutmak için bir int2 sonuç değeri başlatır.

Kısaltma çekirdeği yazma

#pragma rs reduce, bir azaltma çekirdeğini, adını ve çekirdeği oluşturan işlevlerin adlarını ve rollerini belirterek tanımlar. Bu tür işlevlerin tümü static olmalıdır. Azaltma çekirdeği her zaman bir accumulator işlevi gerektirir. Çekirdeğin ne yapmasını istediğinize bağlı olarak diğer işlevlerin bazılarını veya tümünü atlayabilirsiniz.

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

#pragma içindeki öğelerin anlamları şu şekildedir:

reduce(kernelName) (zorunlu): Bir azaltma çekirdeğinin tanımlanmakta olduğunu belirtir. Yansıtılmış bir Java yöntemi reduce_kernelName, çekirdeği başlatır.
initializer(initializerName) (isteğe bağlı): Bu azaltma çekirdeği için ilkleştirici işlevinin adını belirtir. Çekirdeği başlattığınızda RenderScript, her bir toplayıcı veri öğesi için bu işlevi bir kez çağırır. İşlev şu şekilde tanımlanmalıdır:
```
static void initializerName(accumType *accum) { … }
```
accum, bu işlevin başlatılması için toplayıcı veri öğesinin işaretçisidir.

Başlatıcı işlevi sağlamazsanız RenderScript, her toplayıcı veri öğesini sanki memset gibi bir değer ile sıfır olarak başlatır ve aşağıdakine benzer bir başlatıcı işlevi varmış gibi davranır:
```
static void initializerName(accumType *accum) {
  memset(accum, 0, sizeof(*accum));
}
```
accumulator(accumulatorName) (zorunlu): Bu azaltma çekirdeği için toplayıcı işlevinin adını belirtir. Çekirdeği başlattığınızda RenderScript, bir toplayıcı veri öğesini girişlere göre bir şekilde güncellemek için girişlerdeki her koordinat için bu işlevi bir kez çağırır. Fonksiyon şu şekilde tanımlanmalıdır:
```
static void accumulatorName(accumType *accum,
                            in1Type in1, …, inNType inN
                            [, specialArguments]) { … }
```
accum, bu işlevin değiştirmesi için toplayıcı veri öğesinin işaretçisidir. in1 ile inN arası, her giriş için bir bağımsız değişken olmak üzere, çekirdek başlatma işlemine iletilen girişlere göre otomatik olarak doldurulan bir veya daha fazla bağımsız değişkendir. Toplayıcı işlevi, isteğe bağlı olarak özel bağımsız değişkenlerden herhangi birini alabilir.

Çoklu girişe sahip çekirdek örneği: dotProduct.
combiner(combinerName)
(isteğe bağlı): Bu azaltma çekirdeği için birleştirici işlevinin adını belirtir. RenderScript, girişlerdeki her koordinat için toplayıcı işlevini bir kez çağırdıktan sonra, tüm toplayıcı veri öğelerini tek bir toplayıcı veri öğesinde birleştirmek için bu işlevi gerektiği kadar çağırır. Fonksiyon şu şekilde tanımlanmalıdır:
```
static void combinerName(accumType *accum, const accumType *other) { … }
```
accum, bu işlevin değişiklik yapması için "hedef" toplayıcı veri öğesine yönlendiren bir işaretçidir. other, bu işlevin *accum ile "birleştirmesi" için bir "kaynak" toplayıcı veri öğesine işaret eder.

NOT: *accum, *other veya her ikisi de başlatılmış ancak toplayıcı işlevine hiç geçirilmemiş olabilir. Yani, giriş verilerine göre biri veya her ikisi de hiç güncellenmemiş olabilir. Örneğin, findMinAndMax çekirdeğinde fMMCombiner birleştirici işlevi, idx < 0 değerini açık bir şekilde kontrol eder. Çünkü bu, değeri INITVAL olan böyle bir toplayıcı veri öğesini belirtir.

Bir birleştirici işlevi sağlamazsanız, RenderScript yerine aşağıdaki gibi bir birleştirici işlevi varmış gibi davranarak toplama işlevini kullanır:
```
static void combinerName(accumType *accum, const accumType *other) {
  accumulatorName(accum, *other);
}
```
Çekirdekte birden fazla giriş varsa, giriş verisi türü toplayıcı veri türüyle aynı değilse ya da toplayıcı işlevi bir veya daha fazla özel bağımsız değişken alırsa birleştirici işlevi zorunludur.
outconverter(outconverterName) (isteğe bağlı): Bu azaltma çekirdeği için dış dönüştürücü işlevinin adını belirtir. RenderScript, tüm toplayıcı veri öğelerini birleştirdikten sonra, indirgenme işleminin sonucunu Java'ya döndürecek şekilde belirlemek için bu işlevi çağırır. Fonksiyon şu şekilde tanımlanmalıdır:
```
static void outconverterName(resultType *result, const accumType *accum) { … }
```
result, bu işlevin azaltma sonucuyla başlatılması için bir sonuç veri öğesinin (RenderScript çalışma zamanı tarafından tahsis edilen ancak başlatılmayan) bir işaretçidir. resultType, söz konusu veri öğesinin türüdür ve accumType ile aynı olması gerekmez. accum, birleştirici işlevi tarafından hesaplanan son toplayıcı veri öğesine işaret eden bir işaretçidir.

Bir dış dönüştürücü işlevi sağlamazsanız RenderScript, son toplayıcı veri öğesini sonuç veri öğesine kopyalar ve aşağıdaki gibi görünen bir dış dönüştürücü işlevi varmış gibi davranır:
```
static void outconverterName(accumType *result, const accumType *accum) {
  *result = *accum;
}
```
Toplayıcı veri türünden farklı bir sonuç türü istiyorsanız dış dönüştürücü işlevi zorunludur.

Çekirdeğin giriş türleri, toplayıcı veri öğe türü ve sonuç türü olduğunu unutmayın. Bunların hiçbiri aynı olmamalıdır. Örneğin, findMinAndMax çekirdeğinde long giriş türü, toplayıcı verisi öğe türü MinAndMax ve int2 sonuç türü birbirinden farklıdır.

Neleri varsayamazsınız?

Belirli bir çekirdek başlatması için RenderScript tarafından oluşturulan toplayıcı veri öğelerinin sayısına dayanmamanız gerekir. Aynı girişlere sahip aynı çekirdeğin iki kez başlatılmasının aynı sayıda toplayıcı veri öğesi oluşturacağı garanti edilmez.

RenderScript'in başlatıcı, toplayıcı ve birleştirici işlevlerini çağırdığı sıraya güvenmemeniz gerekir; hatta bazı işlevler paralel olarak çağrılabilir. Aynı girişe sahip aynı çekirdeğin iki lansmanının aynı sırayı izleyeceğinin garantisi yoktur. Tek garanti, sadece başlatıcı işlevinin başlatılmamış toplayıcı veri öğesini görmesidir. Örnek:

Tüm toplayıcı veri öğelerinin, toplayıcı işlevi çağrılmadan önce başlatılacağına dair herhangi bir garanti verilmez ancak bu öğeler, yalnızca başlatılmış bir toplayıcı veri öğesinde çağrılır.
Giriş öğelerinin toplayıcı işlevine aktarılma sırası konusunda herhangi bir garanti verilmez.
Birleştirici işlevi çağrılmadan önce toplayıcı işlevinin tüm giriş Öğeleri için çağrılacağına dair herhangi bir garanti verilmez.

Bunun bir sonucu, findMinAndMax çekirdeğinin belirleyici olmamasıdır: Giriş, aynı minimum veya maksimum değerde birden fazla yerde tekrar yer alıyorsa çekirdeğin hangi oluşumu bulacağını bilemezsiniz.

Neyi garanti etmeniz gerekir?

RenderScript sistemi çekirdeği birçok farklı şekilde yürütmeyi seçebildiğinden, çekirdeğinizin istediğiniz şekilde davrandığından emin olmak için belirli kuralları uygulamanız gerekir. Bu kurallara uymazsanız yanlış sonuçlar, belirleyici olmayan davranış veya çalışma zamanı hataları alabilirsiniz.

Aşağıdaki kurallarda genellikle iki toplayıcı veri öğesinin "aynı değere" sahip olması gerektiği belirtilir. Bu ne anlama geliyor? Bu, çekirdeğin ne yapmasını istediğinize bağlıdır. addint gibi matematiksel bir indirme işlemi için "aynı"nın matematiksel eşitlik anlamına gelmesi genellikle anlamlıdır. Aynı giriş değerlerinin birden fazla kez kullanılabileceği findMinAndMax ("minimum ve maksimum giriş değerlerinin konumunu bul") gibi bir "herhangi birini seç" araması için belirli bir giriş değerinin tüm konumları "aynı" olarak kabul edilmelidir. "En soldaki minimum ve maksimum giriş değerlerinin konumunu bulmak" için benzer bir çekirdek yazabilirsiniz. Bu işlev için, örneğin) 100 numaralı konumdaki minimum değerin, 200 numaralı konumdaki özdeş minimum değere tercih edilmesi tercih edilir. Bu çekirdek için "aynı" değeri, yalnızca aynı değer değil, aynı konum anlamına gelir. Toplayıcı ve birleştirici işlevlerinden bulucu ve birleştirici işlevleri de farklı olmalıdır.

Başlatıcı işlevi bir kimlik değeri oluşturmalıdır. Yani I ve A, toplayıcı işlevi tarafından başlatılan toplayıcı veri öğeleriyse ve I toplayıcı işlevine hiç geçirilmediyse (ancak A geçmiş olabilir)

combinerName(&A, &I), A alanını aynı bırakmalıdır
combinerName(&I, &A), I alanını A ile aynı bırakmalıdır

Örnek: addint çekirdeğinde bir toplayıcı veri öğesi sıfır olarak başlatılır. Bu çekirdek için birleştirici işlevi toplama işlemi gerçekleştirir. Sıfır, toplama için kimlik değeridir.

Örnek: findMinAndMax çekirdeğinde bir toplayıcı veri öğesi INITVAL olarak başlatılır.

I INITVAL olduğundan fMMCombiner(&A, &I), A değerini aynı bırakır.
I, INITVAL olduğundan fMMCombiner(&I, &A), I değerini A olarak ayarlar.

Bu nedenle INITVAL aslında bir kimlik değeridir.

Birleştirici işlevi değişimli olmalıdır. Yani A ve B, başlatıcı işlevi tarafından başlatılan toplayıcı veri öğeleriyse ve toplama işlevine sıfır veya daha fazla kez geçirildiyse combinerName(&A, &B), A değerini combinerName(&B, &A) ile B olarak ayarlanan aynı değere ayarlamalıdır.

Örnek: addint çekirdeğinde birleştirici işlevi, iki toplayıcı verisi öğe değerini ekler; toplama ise değişmelidir.

Örnek: findMinAndMax çekirdeğinde fMMCombiner(&A, &B) A = minmax(A, B) ile aynıdır. minmax değişimli olduğu için fMMCombiner de değişkendir.

Birleştirici işlevi ilişkisel olmalıdır. Yani A, B ve C, başlatıcı işlevi tarafından başlatılan toplayıcı veri öğeleriyse ve toplayıcı işlevine sıfır veya daha fazla kez geçirildiyse aşağıdaki iki kod dizisinde A değeri aynı değere ayarlanmalıdır:

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

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

Örnek: addint çekirdeğinde, birleştirici işlevi iki toplayıcı verisi öğe değerini ekler:

A = A + B
A = A + C
// Same as
//   A = (A + B) + C

B = B + C
A = A + B
// Same as
//   A = A + (B + C)
//   B = B + C

Toplama işlemi ilişkilendirildiği gibi birleştirici işlevi de ilişkiseldir.

Örnek: findMinAndMax çekirdeğinde

fMMCombiner(&A, &B)

A = minmax(A, B)

ile aynıdır. Bu nedenle iki dizilim

A = minmax(A, B)
A = minmax(A, C)
// Same as
//   A = minmax(minmax(A, B), C)

B = minmax(B, C)
A = minmax(A, B)
// Same as
//   A = minmax(A, minmax(B, C))
//   B = minmax(B, C)

minmax ilişkisel olduğu için fMMCombiner de ilişkiseldir.

Toplayıcı işlevi ve birleştirici işlevi, birlikte temel katlama kuralına uymalıdır. Diğer bir deyişle, A ve B toplayıcı veri öğeleriyse A, başlatıcı işlevi tarafından başlatılmışsa ve toplayıcı işlevine sıfır veya daha fazla kez geçmiş olabilir, B başlatılmamıştır ve bağımsız değişkenler toplayıcı işlevine yapılan belirli bir çağrıya ait giriş bağımsız değişkenleri ile özel bağımsız değişkenlerin listesidir. Bu durumda aşağıdaki iki kod dizisi A değerini olarak ayarlamalıdır:

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

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

Örnek: addint çekirdeğinde bir V giriş değeri için:

İfade 1, A += V ile aynı
İfade 2, B = 0 ile aynıdır
İfade 3, B += V ile aynı olup B = V ile aynıdır.
İfade 4, A += B ile aynı olup A += V ile aynıdır.

İfade 1 ve 4, A öğesini aynı değere ayarladığından bu çekirdek temel katlama kuralına uyar.

Örnek: findMinAndMax çekirdeğinde, X koordinatındaki V giriş değeri için:

İfade 1, A = minmax(A, IndexedVal(V, X)) ile aynı
İfade 2, B = INITVAL ile aynıdır
İfade 3,
```
B = minmax(B, IndexedVal(V, X))
```
ile aynıdır çünkü B ilk değer olduğundan
```
B = IndexedVal(V, X)
```
ile aynıdır.

İfade 4,

A = minmax(A, IndexedVal(V, X))

ile aynı olan

A = minmax(A, B)

ile aynıdır.

İfade 1 ve 4, A öğesini aynı değere ayarladığından bu çekirdek temel katlama kuralına uyar.

Java kodundan bir azaltma çekirdeğini çağırma

filename.rs dosyasında tanımlanan kernelName adlı bir azaltma çekirdeği için ScriptC_filename sınıfında belirtilen üç yöntem vardır:

Kotlin

// 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

Java

// 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);

Burada, addint çekirdeğinin çağrılmasına ilişkin bazı örnekler verilmiştir:

Kotlin

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()

Java

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. Yöntem, çekirdeğin toplayıcı işlevindeki her giriş bağımsız değişkeni için bir giriş Allocation bağımsız değişkenine sahiptir. RenderScript çalışma zamanı, tüm giriş Ayırmalarının aynı boyutlara sahip olduğundan ve giriş Ayırmalarının her birinin Element türünün, toplayıcı işlevine ait prototipin karşılık gelen giriş bağımsız değişkeniyle eşleştiğinden emin olmak için kontrol yapar. Bu kontrollerden herhangi biri başarısız olursa RenderScript bir istisna oluşturur. Çekirdek, bu boyutlardaki her koordinat üzerinde yürütülür.

2. Yöntem, Yöntem 1 ile aynıdır ancak 2. Yöntem, çekirdek yürütmesini koordinatların bir alt kümesiyle sınırlamak için kullanılabilecek ek bir sc bağımsız değişkenini alır.

3. Yöntem, 1. Yöntem ile aynıdır ancak Ayırma girişleri yerine Java dizisi girişleri alınır. Bu özellik, sizi açıkça bir Ayırma oluşturmak ve bir Java dizisinden buna veri kopyalamak için kod yazma zahmetinden kurtarır. Ancak, Yöntem 1 yerine 3. Yöntemin kullanılması kodun performansını artırmaz. 3. Yöntem, her bir giriş dizisi için uygun Element türü ve setAutoPadding(boolean) etkin olacak şekilde geçici bir 1 boyutlu Ayırma oluşturur ve diziyi, Allocation değerinin uygun copyFrom() yöntemini kullanarak Ayırma'ya kopyalar. Daha sonra, bu geçici Ayırmaları ileterek 1. Yöntemi çağırır.

NOT: Uygulamanız aynı diziyle veya aynı boyutlar ve Öğe türüne sahip farklı dizilerle birden fazla çekirdek çağrısı yapacaksa Ayırmaları 3. Yöntem kullanmak yerine kendiniz özel olarak oluşturarak, doldurarak ve yeniden kullanarak performansı artırabilirsiniz.

Yansıtılan azaltma yöntemlerinin dönüş türü olan javaFutureType, ScriptC_filename sınıfı içinde yansıtılan statik ve iç içe yerleştirilmiş bir sınıftır. Çekirdek çalıştırmasının gelecekteki azalmasını temsil eder. Çalıştırmanın gerçek sonucunu elde etmek için ilgili sınıfın get() yöntemini çağırın. Bu yöntem, javaResultType türünde bir değer döndürür. get() eşzamanlı.

Kotlin

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

Java

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

javaResultType, outconverter işlevinin resultType öğesinde belirlenir. resultType imzasız bir tür (skalar, vektör veya dizi) olmadığı sürece javaResultType doğrudan karşılık gelen Java türüdür. resultType imzalanmamış bir türse ve daha büyük bir Java imzalı tür varsa javaResultType daha büyük Java imzalı türdür; aksi takdirde doğrudan karşılık gelen Java türüdür. Örnek:

resultType, int, int2 veya int[15] ise javaResultType, int, Int2 veya int[] olur. Tüm resultType değerleri, javaResultType ile temsil edilebilir.
resultType, uint, uint2 veya uint[15] ise javaResultType: long, Long2 veya long[] olur. Tüm resultType değerleri, javaResultType ile temsil edilebilir.
resultType ulong, ulong2 veya ulong[15] ise javaResultType long, Long2 veya long[] olur. javaResultType ile temsil edilemeyen belirli resultType değerleri vardır.

javaFutureType, outconverter işlevinin resultType değerine karşılık gelen gelecekteki sonuç türüdür.

resultType bir dizi türü değilse javaFutureType result_resultType olur.
resultType, memberType türündeki üyelerle birlikte Count uzunluğunda bir diziyse javaFutureType değeri resultArrayCount_memberType olur.

Örnek:

Kotlin

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> = …
    }
}

Java

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 bir nesne türüyse (dizi türü dahil) aynı örnekteki her javaFutureType.get() çağrısı aynı nesneyi döndürür.

javaResultType, resultType türündeki tüm değerleri temsil edemezse ve bir azaltma çekirdeği temsil edilemez bir değer oluşturursa javaFutureType.get() bir istisna oluşturur.

3. Yöntem ve devecSiInXType

devecSiInXType, toplayıcı işlevinin ilgili bağımsız değişkeninin inXType'ına karşılık gelen Java türüdür. inXType imzasız bir tür veya vektör türü değilse doğrudan karşılık gelen Java türü devecSiInXType'tır. inXType imzasız skaler bir türse devecSiInXType, aynı boyuttaki imzalı skaler türe doğrudan karşılık gelen Java türüdür. inXType işaretli bir vektör türüyse devecSiInXType, vektör bileşeni türüne doğrudan karşılık gelen Java türüdür. inXType işaretsiz bir vektör türüyse devecSiInXType, vektör bileşeni türüyle aynı boyuttaki imzalı skaler türe doğrudan karşılık gelen Java türüdür. Örnek:

inXType int ise devecSiInXType int olur.
inXType int2 ise devecSiInXType int olur. Dizi, düzleştirilmiş bir gösterimdir: Ayırma'nın 2 bileşenli vektör Öğelerine göre iki kat fazla skalar Öğe içerir. Bu, copyFrom() Allocation yöntemlerinin çalışma şekli ile aynıdır.
inXType uint ise deviceSiInXType int olur. Java dizisindeki işaretli değer, Ayırma'daki aynı bit kalıbının imzalanmamış bir değeri olarak yorumlanır. Bu, Allocation kapsamındaki copyFrom() yöntemlerinin çalışma şeklidir.
inXType uint2 ise deviceSiInXType int olur. Bu, int2 ve uint öğelerinin işlenme şeklinin bir birleşimidir: Dizi, düzleştirilmiş bir gösterimdir ve Java dizisi imzalı değerler RenderScript imzalanmamış Öğe değerleri olarak yorumlanır.

3. Yöntem için giriş türlerinin, sonuç türlerinden farklı şekilde işlendiğini unutmayın:

Bir komut dosyasının vektör girişi Java tarafında düz hale gelirken komut dosyasının vektör sonucu sabitlenmemiştir.
Bir komut dosyasının imzasız girişi, Java tarafında aynı boyutta imzalı bir giriş olarak gösterilirken komut dosyasının imzalanmamış sonucu, Java tarafında genişletilmiş imzalı tür olarak temsil edilir (ulong durumu hariç).

Çekirdek azaltma için diğer örnekler

#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];
}

Ek kod örnekleri

BasicRenderScript, RenderScriptIntrinsic ve Hello Compute örnekleri, bu sayfada ele alınan API'lerin kullanımını daha ayrıntılı bir şekilde gösterir.

RenderScript'e Genel Bakış

RenderScript Çekirdeği Yazma

Kayan nokta hassasiyeti ayarlanıyor

Java'dan RenderScript API'lerine erişme

RenderScript Destek Kitaplığı API'larını kullanma

Eskitme

Kotlin

Kotlin

Java

Java veya Kotlin Kodu'ndan RenderScript'i kullanma

Kotlin

Java

Eşzamansız yürütme modeli

Tek Kaynaklı RenderScript

Kotlin

Java

Komut Dosyası Global'lar

Derinliği Azaltma

Kısaltma çekirdeği yazma

Neleri varsayamazsınız?

Neyi garanti etmeniz gerekir?

Java kodundan bir azaltma çekirdeğini çağırma

Kotlin

Java

Kotlin

Java

Kotlin

Java

Kotlin

Java

3. Yöntem ve devecSiInXType

Çekirdek azaltma için diğer örnekler

Ek kod örnekleri