aaron/ispc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

It is no longer legal to initialize arrays and structs with single

Browse Source 
scalar values (that ispc used to smear across the array/struct
elements).  Now, initializers in variable declarations must be
{ }-delimited lists, with one element per struct member or array
element, respectively.

There were a few problems with the previous implementation of the
functionality to initialize from scalars.  First, the expression
would be evaluated once per value initialized, so if it had side-effects,
the wrong thing would happen.  Next, for large multidimensional arrays,
the generated code would be a long series of move instructions, rather
than loops (and this in turn made LLVM take a long time.)

While both of these problems are fixable, it's a non-trivial
amount of re-plumbing for a questionable feature anyway.

Fixes issue #50.
This commit is contained in:
Matt Pharr
2011-07-01 13:45:58 +01:00
parent a2940d63b4
commit d2d5858be1
40 changed files with 114 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
docs/ReleaseNotes.txt
View File

@@ -1,4 +1,12 @@
=== v1.0.2 ===
=== v1.0.3 === (not yet released)
In initializer expressions with variable declarations, it is no longer
legal to initialize arrays and structs with single scalar values that then
initialize their members; they now must be initialized with initializer
lists in braces (or initialized after of the initializer with a loop over
array elements, etc.)
=== v1.0.2 === (1 July 2011)
Floating-point hexidecimal constants are now parsed correctly on Windows
(fixes issue #16).

8
docs/ispc.txt
View File

@@ -766,22 +766,18 @@ Variables can also be declared in ``for`` statement initializers:
for (int i = 0; ...)
Arrays can be initialized with either a scalar value or with individual
element values in braces:
Arrays can be initialized with individual element values in braces:
::
int foo[10] = x; // all ten elements take the value of x
int bar[2][4] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 } };
Structures can also be initialized both with scalar values or with element
values in braces:
Structures can also be initialized only with element values in braces:
::
struct Color { float r, g, b; };
....
Color c = 1; // all are one
Color d = { 0.5, .75, 1.0 }; // r = 0.5, ...

13
stmt.cpp
View File

@@ -217,21 +217,10 @@ lInitSymbol(llvm::Value *lvalue, const char *symName, const Type *type,
exprList->exprs[i], ctx, pos);
}
}
else if (initExpr->GetType()->IsNumericType() ||
initExpr->GetType()->IsBoolType()) {
// Otherwise initialize all of the elements in turn with the
// initExpr.
for (int i = 0; i < collectionType->GetElementCount(); ++i) {
llvm::Value *ep = ctx->GetElementPtrInst(lvalue, 0, i, "element");
lInitSymbol(ep, symName, collectionType->GetElementType(i),
initExpr, ctx, pos);
}
}
else {
else
Error(initExpr->pos, "Can't assign type \"%s\" to \"%s\".",
initExpr->GetType()->GetString().c_str(),
collectionType->GetString().c_str());
}
return;
}

7
tests/array-assignment-varying-control.ispc
View File

@@ -11,8 +11,11 @@ void f(reference uniform Foo foo[], float a) {
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
float f[40] = a;
float g[40] = b;
float f[40], g[40];
for (uniform int i = 0; i < 40; ++i) {
f[i] = a;
g[i] = b;
}
if (a < 2)
f = g;
RET[programIndex] = f[a];

6
tests/array-mixed-unif-vary-indexing-2.ispc
View File

@@ -5,7 +5,11 @@ export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform float x[47][47] = 2.;
uniform float x[47][47];
for (uniform int i = 0; i < 47; ++i)
for (uniform int j = 0; j < 47; ++j)
x[i][j] = 2;
// all are 2 except (3,4) = 0, (1,4) = 1, (2,4) = 1, (4,4) = 1
if (a == 3.)
x[a][b-1] = 0;

6
tests/array-mixed-unif-vary-indexing-3.ispc
View File

@@ -4,7 +4,11 @@ export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform float x[47][47] = 2.;
uniform float x[47][47];
for (uniform int i = 0; i < 47; ++i)
for (uniform int j = 0; j < 47; ++j)
x[i][j] = 2;
// all are 2 except (4,2) = 0, (4,...) = 1, (4,programCount-1)=2
if (a == 3.)
x[b-1][a-1] = 0;

6
tests/array-mixed-unif-vary-indexing.ispc
View File

@@ -5,7 +5,11 @@ export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform float x[47][74] = 2.;
uniform float x[47][47];
for (uniform int i = 0; i < 47; ++i)
for (uniform int j = 0; j < 47; ++j)
x[i][j] = 2;
x[a][b-1] = 0;
RET[programIndex] = x[2][a];
}

6
tests/array-multidim-gather-scatter.ispc
View File

@@ -4,7 +4,11 @@ export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
float x[40][40] = b;
float x[40][40];
for (uniform int i = 0; i < 40; ++i)
for (uniform int j = 0; j < 40; ++j)
x[i][j] = b;
uniform int index[4] = { 0, 1, 2, 4 };
float v = index[programIndex & 0x3];
x[a][v] = 0;

4
tests/array-scatter-unif.ispc
View File

@@ -5,7 +5,9 @@ export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform float x[40] = 0;
uniform float x[40];
for (uniform int i = 0; i < 40; ++i)
x[i] = 0.;
x[a] = 2;
RET[programIndex] = x[4] + x[0] + x[5];
}

6
tests/nested-structs-2.ispc
View File

@@ -13,7 +13,11 @@ struct Bar {
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform Bar bar = 2.;
uniform Bar bar;
for (uniform int i = 0; i < 6; ++i)
for (uniform int j = 0; j < 18; ++j)
bar.foo[i].f[j] = 2.;
bar.foo[5].f[a] = a;
RET[programIndex] = bar.foo[b].f[a];
}

5
tests/nested-structs.ispc
View File

@@ -13,7 +13,10 @@ struct Bar {
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform Bar bar = 2.;
uniform Bar bar;
for (uniform int i = 0; i < 6; ++i)
for (uniform int j = 0; j < 6; ++j)
bar.foo[i].f[j] = 2.;
RET[programIndex] = bar.foo[b].f[b];
}

5
tests/op-plus-equals-ensure-one-lhs-eval.ispc
View File

@@ -2,7 +2,10 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
uniform float foo[16] = 1;
uniform float foo[16];
for (uniform int i = 0; i < 16; ++i)
foo[i] = 1;
uniform int i = 0;
foo[i++] += 1;
ret[programIndex] = i;

4
tests/packed-store-1.ispc
View File

@@ -3,7 +3,9 @@ export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
float a = aFOO[programIndex];
uniform int pack[2+programCount] = 0;
uniform int pack[2+programCount];
for (uniform int i = 0; i < 2+programCount; ++i)
pack[i] = 0;
packed_store_active(pack, 2, a);
RET[programIndex] = pack[programIndex];
}

4
tests/packed-store-2.ispc
View File

@@ -3,7 +3,9 @@ export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
float a = aFOO[programIndex];
uniform int pack[2+programCount] = 0;
uniform int pack[2+programCount];
for (uniform int i = 0; i < 2+programCount; ++i)
pack[i] = 0;
if ((int)a & 1)
packed_store_active(pack, 2, a);
RET[programIndex] = pack[programIndex];

4
tests/packed-store-3.ispc
View File

@@ -3,7 +3,9 @@ export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
float a = aFOO[programIndex];
uniform int pack[2+programCount] = 0;
uniform int pack[2+programCount];
for (uniform int i = 0; i < 2+programCount; ++i)
pack[i] = 0;
uniform int count = 0;
if ((int)a & 1)
count += packed_store_active(pack, 2, a);

4
tests/packed-store.ispc
View File

@@ -3,7 +3,9 @@ export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
float a = aFOO[programIndex];
uniform int pack[programCount] = 0;
uniform int pack[programCount];
for (uniform int i = 0; i < programCount; ++i)
pack[i] = 0;
packed_store_active(pack, 0, a);
RET[programIndex] = pack[programIndex];
}

4
tests/pass-varying-lvalue-to-ref.ispc
View File

@@ -4,7 +4,9 @@ export uniform int width() { return programCount; }
void inc(reference float v) { ++v; }
export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
uniform float foo[32] = 10;
uniform float foo[32];
for (uniform int i = 0; i < 32; ++i)
foo[i] = 10;
int a = (int)aa[programIndex];
inc(foo[a]);
ret[programIndex] = foo[programIndex];

2
tests/short-circuit.ispc
View File

@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
export void f_f(uniform float RET[], uniform float aFOO[]) {
float a = aFOO[programIndex];
uniform float array[4] = 1;
uniform float array[4] = {1,1,1,1};
int index = 1000 * (a-1);
RET[programIndex] = (programIndex == 0) ? array[index] : 2.;
}

4
tests/store-int16.ispc
View File

@@ -1,7 +1,9 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int x[16] = 0xffffffff;
uniform int x[16];
for (uniform int i = 0; i < 16; ++i)
x[i] = 0xffffffff;
unsigned int val = aFOO[programIndex];
store_to_int16(x, 5, val);
unsigned int v = load_from_int16(x, 6);

4
tests/store-int8.ispc
View File

@@ -1,7 +1,9 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
uniform int x[8] = 0xffffffff;
uniform int x[8];
for (uniform int i = 0; i < 8; ++i)
x[i] = 0xffffffff;
unsigned int val = aFOO[programIndex];
store_to_int8(x, 2, val);
unsigned int v = load_from_int8(x, 1);

4
tests/struct-ref-lvalue.ispc
View File

@@ -11,7 +11,9 @@ void f(reference uniform Foo foo[], float a) {
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform Foo foo[17] = a;
uniform Foo foo[17];
for (uniform int i = 0; i < 17; ++i)
foo[i].f = a;
f(foo, a);
RET[programIndex] = foo[a].f;
}

2
tests/struct-test-117.ispc
View File

@@ -9,7 +9,7 @@ struct Foo {
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
varying Foo myFoo = a;
varying Foo myFoo = { a, a };
RET[programIndex] = myFoo.x;
}

2
tests/struct-test-118.ispc
View File

@@ -8,7 +8,7 @@ struct Foo {
};
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform Foo myFoo[3] = a;
uniform Foo myFoo[3] = { { a, a }, {a, a}, {a, a} };
int i = 1;
varying Foo barFoo = myFoo[i];
RET[programIndex] = barFoo.x;

4
tests/struct-test-119.ispc
View File

@@ -10,7 +10,9 @@ struct Foo {
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
varying Foo myFoo[3] = b;
varying Foo myFoo[3] = { { b, b, {b, b, b} },
{ b, b, {b, b, b} },
{ b, b, {b, b, b} } };
uniform Foo barFoo;
barFoo = myFoo[0];
RET[programIndex] = barFoo.x + myFoo[1].i[2];

4
tests/struct-test-120.ispc
View File

@@ -11,7 +11,9 @@ float bar(struct Foo f) { return f.f; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
varying Foo myFoo[3] = a;
varying Foo myFoo[3] = { { a, a, {a, a, a} },
{ a, a, {a, a, a} },
{ a, a, {a, a, a} } };
RET[programIndex] = bar(myFoo[1]);
}

2
tests/struct-test-121.ispc
View File

@@ -10,7 +10,7 @@ float bar(varying Foo f) { ++f.x; return f.x; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
varying Foo f = a;
varying Foo f = { a };
bar(f);
RET[programIndex] = f.x;
}

2
tests/struct-test-122.ispc
View File

@@ -9,7 +9,7 @@ float bar(reference varying Foo f) { ++f.x; return f.x; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
varying Foo f = a;
varying Foo f = {a};
bar(f);
RET[programIndex] = f.x;
}

2
tests/struct-test-123.ispc
View File

@@ -9,7 +9,7 @@ void bar(reference varying Foo f) { ++f.x; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
varying Foo f = a;
varying Foo f = {a};
if (a == 1 || a == 4)
bar(f);
RET[programIndex] = f.x;

4
tests/struct-vary-index-expr.ispc
View File

@@ -7,7 +7,9 @@ struct Foo { float f; };
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform Foo foo[17] = a;
uniform Foo foo[17];
for (uniform int i = 0; i < 17; ++i)
foo[i].f = a;
++foo[a].f;
uniform int i[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
RET[programIndex] = foo[i[programIndex]].f;

4
tests/test-98.ispc
View File

@@ -4,7 +4,9 @@ export uniform int width() { return programCount; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform int x[7] = b;
uniform int x[7];
for (uniform int i = 0; i < 7; ++i)
x[i] = b;
RET[programIndex] = x[b];
}

5
tests/typedef-2.ispc
View File

@@ -15,7 +15,10 @@ struct Bar {
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
Bar bar = b;
Bar bar;
for (uniform int i = 0; i < 16; ++i)
for (uniform int j = 0; j < 16; ++j)
bar.foo[i].x[j] = b;
RET[programIndex] = bar.foo[a-1].x[a-1];
}

2
tests/unif-struct-test-116.ispc
View File

@@ -8,7 +8,7 @@ struct Foo {
};
export void f_fi(uniform float RET[], uniform float a[], uniform int b[]) {
uniform struct Foo myFoo = 2;
uniform struct Foo myFoo = {2,2};
RET[programIndex] = myFoo.x + myFoo.f;
}

2
tests/unif-struct-test-117.ispc
View File

@@ -8,7 +8,7 @@ struct Foo {
};
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform struct Foo myFoo = a;
uniform struct Foo myFoo = {a,a};
RET[programIndex] = myFoo.x;
}

2
tests/unif-struct-test-118.ispc
View File

@@ -8,7 +8,7 @@ struct Foo {
};
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform struct Foo myFoo[3] = a;
uniform struct Foo myFoo[3] = { { a,a}, {a,a}, {a,a} };
uniform struct Foo barFoo;
barFoo = myFoo[1];
RET[programIndex] = barFoo.x;

4
tests/unif-struct-test-119.ispc
View File

@@ -10,7 +10,9 @@ struct Foo {
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform struct Foo myFoo[3] = b;
uniform struct Foo myFoo[3] = { { b, b, {b, b, b} },
{ b, b, {b, b, b} },
{ b, b, {b, b, b} } };
uniform struct Foo barFoo;
barFoo = myFoo[0];
RET[programIndex] = barFoo.x + myFoo[1].i[2];

4
tests/unif-struct-test-120.ispc
View File

@@ -10,7 +10,9 @@ struct Foo {
float bar(uniform struct Foo f) { return f.f; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform struct Foo myFoo[3] = a;
uniform struct Foo myFoo[3] = { { a, a, {a, a, a} },
{ a, a, {a, a, a} },
{ a, a, {a, a, a} } };
RET[programIndex] = bar(myFoo[1]);
}

2
tests/unif-struct-test-121.ispc
View File

@@ -9,7 +9,7 @@ float bar(uniform struct Foo f) { ++f.x; return f.x; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform struct Foo f = a;
uniform struct Foo f = { a };
bar(f);
RET[programIndex] = f.x;
}

2
tests/unif-struct-test-122.ispc
View File

@@ -9,7 +9,7 @@ float bar(reference uniform struct Foo f) { ++f.x; return f.x; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform struct Foo f = a;
uniform struct Foo f = {a};
bar(f);
RET[programIndex] = f.x;
}

2
tests/unif-struct-test-123.ispc
View File

@@ -8,7 +8,7 @@ struct Foo {
void bar(reference uniform struct Foo f) { ++f.x; }
export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
float a = aFOO[programIndex];
uniform struct Foo f = a;
uniform struct Foo f = {a};
if (a == 1 || a == 4)
bar(f);
RET[programIndex] = f.x;

4
tests/write-same-loc.ispc
View File

@@ -2,7 +2,9 @@
export uniform int width() { return programCount; }
export void f_fu(uniform float ret[], uniform float aa[], uniform float b) {
uniform int foo[10] = 10;
uniform int foo[10];
for (uniform int i = 0; i < 10; ++i)
foo[i] = 10;
int bb = b;
foo[bb] = 0;
ret[programIndex] = foo[4] + foo[5];