Grafik (C++ amp)
C++ AMP, GPU üzerindeki doku desteğine erişmek için kullanabileceğiniz Concurrency::graphics ad alanınındaki bir çok API'yı içerir.Bazı ortak senaryolar:
texture sınıfını; veri konteynırı olarak, önbellek dokusunun spatial locality 'nı işletmekte veya GPU donanım diziliminde kullanabilirsiniz.Konumsal yerellik , fiziksel olarak birbirlerine yakın olan veri öğelerinin özelliğidir.
Çalışma zamanı, hesaplama ile ilgili olmayan gölgelendiriciler ile birlikte etkili çalışabilirlik sağlar.Piksel, tepe, tesselasyon ve hull gölgelendiricileri sıklıkla C++ AMP hesaplamalarında kulanabileceğiniz dokuları üretir veya tüketirler.
Grafik C++ amp API'leri erişim için alternatif yollar paketlenmiş arabellekleri sub-word sağlar.texels (doku öğeleri) 8 veya 16 bitten oluşan, bu gibi paket veri depolarına ulaşıma izin veren sayılları temsil eden formatlara sahip dokular.
[!NOT]
C++ AMP APIleri doku örnekleme ve süzme işlevselliği sağlamaz.DirectCompute ve HLSL'da kod yazmadan önce C++ AMP birlikte kullanılabilirlik özelliklerini kullanmalısınız
Norm ve unorm türleri
norm ve unorm türleri, float değer aralığını sınırlayan skalar türlerdir. Bu clamping olarak bilinir.Bu türler, diğer skalar türlerden yararlanarak açıkça oluşturulabilir.Atama yapılırken, değer önce float atanır sonra [-1.0…1.0] ya da unorm [0.0…1.0] tarafından izin verilen ayrı bölgeye sıkıştırılırlar.+/- sonsuz'dan atam yaparak +/-1'i döndürür.NaN'dan atama tanımsızdır.Unorm örtülü olarak, veri kaybı olmaksızın bir normu oluşturabilir.Kayma için örtük dönüştürücü, bu türlerde tanımlanmıştır.İkili işleçler bu türler arasında tanımlıdır ve diğer gömme skalar türler: float ve int: +, -, *, /, ==,! =, >, <>, =, < =.Bileşik atama işleçleri bunları da destekler: +=,-=, * = / =.Tekli negatif işleç (-) norma türleri için tanımlıdır.
Kısa vektör Kitaplığı
Kısa vektör Kitaplığı, HSL'de tanımlanan ve tipik olarak görüntü doku hücresini tanımlamada kullanılır Vector Type için bazı fonsiyonları sağlar.Kısa vektör, aynı türün bir-dört arası değerlerini tutan bir veri yapısıdır.Desteklenen türler double, float, int, norm, uint, ve unorm'dir.Tür adları aşağıdaki tabloda gösterilmiştir.Her tür için ayrıca isminde altçizgi bulunmayan bir karşılık typedef vardır.Altçizgi olan türler CONCURRENCY::Graphics ad alanı 'in içindedir.Alt çizgi olmayan türler CONCURRENCY::Graphics::Direct3D ad alanı 'in içindedir. Böylelikle bunlar, __int8 ve __int16 gibi benzer isimlendirilmiş temel türlerden kolaylıkla ayrılırlar.
Uzunluk 2 |
Uzunluk 3 |
Uzunluk 4 |
|
|---|---|---|---|
double |
double_2 double2 |
double_3 double3 |
double_4 double4 |
float |
float_2 float2 |
float_3 float3 |
float_4 float4 |
int |
int_2 int2 |
int_3 int3 |
int_4 int4 |
norm |
norm_2 norm2 |
norm_3 norm3 |
norm_4 norm4 |
uint |
uint_2 uint2 |
uint_3 uint3 |
uint_4 uint4 |
unorm |
unorm_2 unorm2 |
unorm_3 unorm3 |
unorm_4 unorm4 |
.gif "Hh913015.collapse_all(tr-tr,VS.110).gif")
İşleçler
Bir işleç iki kısa vektör arasında tanımlı ise, bir kısa vektör ve bir skalar değerin arasında da tanımlıdır.Ayrıca, bunlardan birinin doğru olması gerekir:
Skalar değerin türü kısa vektörün öğe türü ile aynı olmalıdır.
Skalar değerin türü, yalnızca bir kullanıcı tanımlı dönüştürme kullanılarak vector öğesinin öğe türüne örtülü olarak dönüştürülebilir.
İşlem, kısa vektorün her bileşeni ve skalar sayı arasında bileşen odaklı yürütülür.Geçerli işleçler şunlardır:
İşleç türü |
Geçerli türler |
|---|---|
İkili operatörler |
Tüm türlerde geçerliler: +, -, *, /, Tamsayılarda geçerliler: %, ^, | &, <<>>, İki vektörün aynı boyutta olması gerekir ve sonuç aynı boyutta bir vektördür. |
İlişkisel İşleçler |
Tüm türlerde geçerliler i: == ve! = |
Bileşik Atama İşleci |
Tüm türlerde geçerliler: +, -, *, /, Tamsayılarda geçerliler: %, ^, | &, <<>>, |
Artırma ve azaltma işleçleri |
Tüm türlerde geçerliler: +, -, *, /, Hem önekler hem de sonekler geçerlidir. |
Bitsel NOT işleci (~) |
Tamsayılarda geçerliler. |
Tekli İşleç |
unorm ve uint dışında geçerliler. |
Swizzling İfadeleri
Kısa Vektör Kitaplığı vector_type.identifier bir kısa vektörün bileşenlerine erişim için oluşturulan erişimciyi destekler.swizzling expression olarak bilinen identifier, vektörün bileşenlerini belirtir.İfade, l-değeri ya da bir r-değeri olabilir.Tanımlayıcıdaki karakterler x, y, z ve w; ya r, g, b ve a olabilir. "x"ve"r" sıfırıncı bileşeni, "y"ve"g" ilk bileşeni gösteririr. Kural böyle devam eder.(Dikkat edin, "x" ve "r" aynı tanımlayıcıda kullanılamaz.) Bu nedenle, "rgba" ve "xyzw" aynı sonucu verir."x" ve "y" gibi Tek Bileşenli Erişimciler skalar değer türleridir.Çok Bileşenli Erişimcilerini kısa vektör türleridir.Örneğin, fourInts adlı, 2, 4, 6 ve 8 değerlerine sahip bir int_4 vektörü oluşturursanız; fourInts.y 4 tamsayısını, fourInts.rg 2 ve 4 değerlerine sahip int_2 nesnesini döndürür.
Doku Sınıfları
Çoğu GPU'nun piksel ve görüntü doku hücrelerini getirmek, görüntüleri ve dokuları işlemek için optimize edilmiş donanımları ve önbellekleri vardır.Görüntü doku hücre nesneleri için kapsayıcı sınıf olan texture<T,N> sınıfı bu GPU'lara doku işlevselliği sunar.Bir görüntü doku hücresi aşağıdakilerden biri gibi olabilir:
Bir int, uint, float, double, norm, ya da unorm skalar değer.
Bir kıs vektör iki veya dört bileşenden oluşur.Tek istisna double_4 olabilir. Buna izin verilmez.
texture nesnesi 1, 2, veya 3 derecesine sahip olabilir.texture yalnızca parallel_for_each 'e çağrıyla lambdadaki referans ile yakalanabilir.Doku, GPU üzerinde Direct3D Doku nesneleri olarak saklanır.Dokular ve Direct3d görüntü doku hücreleri hakkında daha fazla bilgi için bkz: Introduction to Textures in Direct3D 11.
Kullandığınız görüntü doku hücresi türü, grafik programlamada kullanılan pek çok doku biçiminden biri olabilir.Örneğin, RGBA biçimi 32 biti R, G, B, ve A skalar değer elementlerinin her biri için 8 bit olarak kullanabilir.Biçime bağlı olarak grafik kartının doku donanımı öğelerine ayrı ayrı erişilebilir.Örneğin, doku donanım rgba biçimi kullanıyorsanız, 32-bit forma her 8 bit öğe ayıklayabilirsiniz.C++ amp bit kaydırma kullanmadan kodunda skalar tek tek öğeleri otomatik olarak erişebilmesini sağlamak sizin texel skalar öğesi başına bit ayarlayabilirsiniz.
Doku nesneleri örnekleme
Ön değer atamadan doku nesnesini bildirebilirsiniz.Aşağıdaki kod örneği, benzer doku nesnelerini bildirir.
#include <amp.h>
#include <amp_graphics.h>
using namespace concurrency;
using namespace concurrency::graphics;
void declareTextures() {
// Create a 16-texel texture of int.
texture<int, 1> intTexture1(16);
texture<int, 1> intTexture2(extent<1>(16));
// Create a 16 x 32 texture of float_2.
texture<float_2, 2> floatTexture1(16, 32);
texture<float_2, 2> floatTexture2(extent<2>(16, 32));
// Create a 2 x 4 x 8 texture of uint_4.
texture<uint_4, 3> uintTexture1(2, 4, 8);
texture<uint_4, 3> uintTexture2(extent<3>(2, 4, 8));
}
Bir texture nesnesini bildirmek ve başlatmak için bir oluşturucu kullanılabilir.Aşapıdaki kod örneği, float_4 nesnelerinin bir vektöründen texture nesnesini başlatır.Ölçülebilen öğe başına düşen bitler varsayılan değere ayarlanır.Ölçülebilen öğe varsayılan bitlere sahip olmadığı için bu oluşturucuyu norm, unorm ya da norm ve unorm 'nin kısa vektörü olarak kullanamazsınız.
#include <amp.h>
#include <amp_graphics.h>
#include <vector>
using namespace concurrency;
using namespace concurrency::graphics;
void initializeTexture() {
std::vector<int_4> texels;
for (int i = 0; i < 768 * 1024; i++) {
int_4 i4(i, i, i, i);
texels.push_back(i4);
}
texture<int_4, 2> aTexture(768, 1024, texels.begin(), texels.end());
}
İşaretleyiciyi kaynak veriye yönlendiren fazla yüklü oluşturucu kullanarak texture nesnesini bildirebilir ve başlatabilirsinz. Kaynak verinin boyutu bit türündedir. Skalar öğe başına bit ile hesaplanır.
void createTextureWithBPC() {
// Create the source data.
float source[1024 * 2];
for (int i = 0; i < 1024 * 2; i++) {
source[i] = (float)i;
}
// Initialize the texture by using the size of source in bytes
// and bits per scalar element.
texture<float_2, 1> floatTexture(1024, source, (unsigned int)sizeof(source), 32U);
}
Bu örneklerdeki dokular varsayılan hızlandırıcının varsayılan görünümünde oluşturulur.Bir accelerator_view nesnesini belirtmek isterseniz oluşturucunun diğer aşırı yüklerini kullanabilirsiniz.CPU hızlandırıcısının üzerinde bir doku nesnesi oluşturamazsınız.
Bir texture nesnesinin her boyutunun sınırlarının limiti aşağıdaki tabloda gösterildiği gibidir.Sınırları aşılması sonucunda bir çalışma zamanı hatası oluşturulur.
Doku |
Boyut sınırlandırılması |
|---|---|
Doku<T,1> |
16384 |
Doku<T,2> |
16384 |
Doku<T,2> |
2048 |
Doku nesnelerinden okuma
Bir texture nesnesini doku::işleç[] operatörünü, doku::işleç() operatörü veya texture::GET yöntemi 'ni kullanarak okuyabilirsiniz.doku::işleç[] operatörünü ve doku::işleç() operatörü bir değer döndürür. Bu başvuru değildir.Bu nedenle, bir texture nesnesini doku::işleç[] operatörünü kullanarak yazamazsınız.
void readTexture() {
std::vector<int_2> src;
for (int i = 0; i < 16 *32; i++) {
int_2 i2(i, i);
src.push_back(i2);
}
std::vector<int_2> dst(16 * 32);
array_view<int_2, 2> arr(16, 32, dst);
arr.discard_data();
const texture<int_2, 2> tex9(16, 32, src.begin(), src.end());
parallel_for_each(tex9.extent, [=, &tex9] (index<2> idx) restrict(amp) {
// Use the subscript operator.
arr[idx].x += tex9[idx].x;
// Use the function () operator.
arr[idx].x += tex9(idx).x;
// Use the get method.
arr[idx].y += tex9.get(idx).y;
// Use the function () operator.
arr[idx].y += tex9(idx[0], idx[1]).y;
});
arr.synchronize();
}
Aşağıdaki kod örneği, kısa bir vektör içindeki doku kanallarını ve kısa vektörün özellikleri olarak ölçülebilen öğelerin tek tek nasıl bağlandığını gösterir.
void UseBitsPerScalarElement() {
// Create the image data.
// Each unsigned int (32-bit) represents four 8-bit scalar elements(r,g,b,a values).
const int image_height = 16;
const int image_width = 16;
std::vector<unsigned int> image(image_height * image_width);
extent<2> image_extent(image_height, image_width);
// By using uint_4 and 8 bits per channel, each 8-bit channel in the data source is
// stored in one 32-bit component of a uint_4.
texture<uint_4, 2> image_texture(image_extent, image.data(), image_extent.size() * 4U, 8U);
// Use can access the RGBA values of the source data by using swizzling expressions of the uint_4.
parallel_for_each(image_extent,
[&image_texture](index<2> idx) restrict(amp)
{
// 4 bytes are automatically extracted when reading.
uint_4 color = image_texture[idx];
unsigned int r = color.r;
unsigned int g = color.g;
unsigned int b = color.b;
unsigned int a = color.a;
});
}
Sıralanan vektör türünün her kanaldaki geçerli biti aşağıdaki tabloda listelenmektedir.
Doku veri türü |
Ölçülebilen öğe başına düşen geçerli bitler |
|---|---|
int, int_2, int_4 uint, uint_2, uint_4 |
8, 16, 32 |
float, float_2, float_4 |
16, 32 |
çift, çift_2 |
64 |
norm, norm_2, norm_4 unorm, unorm_2, unorm, 4 |
8, 16 |
Doku nesnelerine yazma
texture nesnelerini yazmak için texture::set yönetimi kullanılır.Doku nesnesi, salt okunur veya okuma/yazma olabilir.Doku nesnesinin okunabilir ve yazılabilir olmas içim aşağıdaki koşulların doğru olması gerekir:
T'nin ölçülebilir tek bir bileşeni vardır.(Kısa vektörlere izin verilmez.)
T double, norm veya unorm değildir.
Bir texture::bits_per_scalar_element özelliği 32'dir.
Eğer bu üçü doğru değilse, texture nesnesi salt okunur bir nesnedir.İlk iki koşul derleme sırasında denetlenir.Bir readonly doku nesnesine yazmaya çalışan bir kodunuz varsa, derleme hatası ortaya çıkar.texture::bits_per_scalar_element için koşul çalışma zamanında algılanır ve salt okunur texture nesnesini yazmaya çalıştığınızda çalışma zamanı unsupported_feature hatasını oluşturur.
Aşağıdaki kod örneği bir doku nesnesine değerleri yazar.
void writeTexture() {
texture<int, 1> tex1(16);
parallel_for_each(tex1.extent, [&tex1] (index<1> idx) restrict(amp) {
tex1.set(idx, 0);
});
}
writeonly_texture_view nesnesini kullanma
Bir Writeonly_texture_view sınıfı, bir doku nesnesinin salt yazılır görünümünü sağlar.Bir writeonly_texture_view nesnesi lambda ifade değerinden yakalamalıdır.Aşağıdaki kod örneği, iki bileşenden oluşan (int_2) texture nesnesine yazmak için writeonly_texture_view nesnesini kullanır.
void write2ComponentTexture() {
texture<int_2, 1> tex4(16);
writeonly_texture_view<int_2, 1> wo_tv4(tex4);
parallel_for_each(extent<1>(16), [=] (index<1> idx) restrict(amp) {
wo_tv4.set(idx, int_2(1, 1));
});
}
Doku nesneleri kopyalama
copy veya copy_async işlevini kullanarak doku nesnelerinin kopyanabilmesi aşağıdaki kod örneğinde gösterildiği gibi kullanılır.
void copyHostArrayToTexture() {
// Copy from source array to texture object by using the copy function.
float floatSource[1024 * 2];
for (int i = 0; i < 1024 * 2; i++) {
floatSource[i] = (float)i;
}
texture<float_2, 1> floatTexture(1024);
copy(floatSource, (unsigned int)sizeof(floatSource), floatTexture);
// Copy from source array to texture object by using the copy function.
char charSource[16 * 16];
for (int i = 0; i < 16 * 16; i++) {
charSource[i] = (char)i;
}
texture<int, 2> charTexture(16, 16, 8U);
copy(charSource, (unsigned int)sizeof(charSource), charTexture);
// Copy from texture object to source array by using the copy function.
copy(charTexture, charSource, (unsigned int)sizeof(charSource));
}
Aynı zamanda bir dokuyu diğerine texture::copy_to yöntemini kullanarak kopyalayabilirsiniz.Bu iki doku üzerinde farklı hızlandırıcı görünümleri olabilir.Bir writeonly_texture_view nesnesine kopyaladığınızda veriler altı çizili texture nesnesine kopyalanır.Her skalar öğenin biti ve derecesi kaynak ve hedef texture nesnesinde aynı olmalıdır.Bu gereksinimler karşılanmadığında, çalışma zamanı bir istisna atar.
Birlikte çalışabilirlik
Bir C++ AMP çalışma zamanı texture<T,1> ve ID3D11Texture1D arabirim ve aynı zamanda texture<T,2> ve ID3D11Texture2D arabirimve bunun yanında texture<T,3> ve ID3D11Texture3D arabirim arasında birlikte çalışmayı destekler.get_texture yöntemi texture nesnesini alır ve IUnknown arayüzünü döndürür.make_texture yöntemi IUnknown arayüzünü ve accelerator_view nesnesi alır ve texture nesnesini döndürür.