Skip to content

Commit

Permalink
using static
Browse files Browse the repository at this point in the history
  • Loading branch information
@FeiPengIntel
FeiPengIntel committed Jun 27, 2018
1 parent a873e29 commit a875409
Show file tree
Hide file tree
Showing 10 changed files with 153 additions and 140 deletions.
3 changes: 2 additions & 1 deletion .gitignore
View file
@@ -1,2 +1,3 @@
bin/
obj/
obj/
.vscode/
4 changes: 2 additions & 2 deletions Color.cs
View file
@@ -1,5 +1,5 @@
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;
using static System.Runtime.Intrinsics.X86.Avx;

internal struct Color
{
Expand All @@ -18,6 +18,6 @@ public Color(float _r, float _g, float _b)

public VectorPacket256 ToColorPacket256()
{
return new VectorPacket256(Avx.SetAllVector256(R), Avx.SetAllVector256(G), Avx.SetAllVector256(B));
return new VectorPacket256(SetAllVector256(R), SetAllVector256(G), SetAllVector256(B));
}
}
27 changes: 14 additions & 13 deletions ColorPacket.cs
View file
@@ -1,3 +1,4 @@
using static System.Runtime.Intrinsics.X86.Avx;
using System.Runtime.Intrinsics.X86;
using System.Runtime.Intrinsics;

Expand All @@ -7,26 +8,26 @@ internal static class ColorPacket256Helper
{
public static Int32RGBPacket256 ConvertToIntRGB(this VectorPacket256 colors)
{
var one = Avx.SetAllVector256<float>(1.0f);
var max = Avx.SetAllVector256<float>(255.0f);
var one = SetAllVector256<float>(1.0f);
var max = SetAllVector256<float>(255.0f);

var rsMask = Avx.Compare(colors.xs, one, FloatComparisonMode.GreaterThanOrderedNonSignaling);
var gsMask = Avx.Compare(colors.ys, one, FloatComparisonMode.GreaterThanOrderedNonSignaling);;
var bsMask = Avx.Compare(colors.zs, one, FloatComparisonMode.GreaterThanOrderedNonSignaling);
var rsMask = Compare(colors.xs, one, FloatComparisonMode.GreaterThanOrderedNonSignaling);
var gsMask = Compare(colors.ys, one, FloatComparisonMode.GreaterThanOrderedNonSignaling);;
var bsMask = Compare(colors.zs, one, FloatComparisonMode.GreaterThanOrderedNonSignaling);

var rs = Avx.BlendVariable(colors.xs, one, rsMask);
var gs = Avx.BlendVariable(colors.ys, one, gsMask);
var bs = Avx.BlendVariable(colors.zs, one, bsMask);
var rs = BlendVariable(colors.xs, one, rsMask);
var gs = BlendVariable(colors.ys, one, gsMask);
var bs = BlendVariable(colors.zs, one, bsMask);

var rsInt = Avx.ConvertToVector256Int32(Avx.Multiply(rs, max));
var gsInt = Avx.ConvertToVector256Int32(Avx.Multiply(gs, max));
var bsInt = Avx.ConvertToVector256Int32(Avx.Multiply(bs, max));
var rsInt = ConvertToVector256Int32(Multiply(rs, max));
var gsInt = ConvertToVector256Int32(Multiply(gs, max));
var bsInt = ConvertToVector256Int32(Multiply(bs, max));

return new Int32RGBPacket256(rsInt, gsInt, bsInt);
}

public static ColorPacket256 BackgroundColor = new ColorPacket256(Avx.SetZeroVector256<float>());
public static ColorPacket256 DefaultColor = new ColorPacket256(Avx.SetZeroVector256<float>());
public static ColorPacket256 BackgroundColor = new ColorPacket256(SetZeroVector256<float>());
public static ColorPacket256 DefaultColor = new ColorPacket256(SetZeroVector256<float>());
}

internal struct Int32RGBPacket256
Expand Down
12 changes: 7 additions & 5 deletions Intersections.cs
View file
@@ -1,3 +1,5 @@
using static System.Runtime.Intrinsics.X86.Avx;
using static System.Runtime.Intrinsics.X86.Avx2;
using System.Runtime.Intrinsics.X86;
using System.Runtime.Intrinsics;
using System;
Expand All @@ -17,21 +19,21 @@ public Intersections(Vector256<float> dis, Vector256<int> things)
ThingIndex = things;
}

public static Intersections Null = new Intersections(Avx.SetAllVector256<float>(Intersections.NullValue), Avx.SetAllVector256<int>(-1));
public static Intersections Null = new Intersections(SetAllVector256<float>(Intersections.NullValue), SetAllVector256<int>(-1));

public bool AllNullIntersections()
{
var cmp = Avx.Compare(Distances, Avx.SetAllVector256<float>(Intersections.NullValue), FloatComparisonMode.EqualOrderedNonSignaling);
var zero = Avx.SetZeroVector256<int>();
var cmp = Compare(Distances, SetAllVector256<float>(Intersections.NullValue), FloatComparisonMode.EqualOrderedNonSignaling);
var zero = SetZeroVector256<int>();
var mask = Avx2.CompareEqual(zero, zero);
return Avx.TestC(cmp, Avx.StaticCast<int, float>(mask));
return TestC(cmp, StaticCast<int, float>(mask));
}

public unsafe int[] WithThings()
{
var result = new int[VectorPacket256.Packet256Size];
fixed (int* ptr = result){
Avx.Store(ptr, ThingIndex);
Store(ptr, ThingIndex);
}
return result;
}
Expand Down
65 changes: 34 additions & 31 deletions PacketTracer.cs
View file
@@ -1,4 +1,7 @@
using System.Runtime.Intrinsics.X86;
using static System.Runtime.Intrinsics.X86.Avx;
using static System.Runtime.Intrinsics.X86.Avx2;
using static System.Runtime.Intrinsics.X86.Sse2;
using System.Runtime.Intrinsics;
using System.Collections.Generic;

Expand Down Expand Up @@ -29,39 +32,39 @@ internal unsafe void RenderVectorized(Scene scene, int[] rgb)
for (int x = 0; x < Width; x += VectorPacket256.Packet256Size)
{
float fx = (float)x;
Vector256<float> xs = Avx.SetVector256(fx, fx+1, fx+2, fx+3, fx+4, fx+5, fx+6, fx+7);
var dirs = GetVectorPacket256(xs, Avx.SetAllVector256((float)y), camera);
Vector256<float> xs = SetVector256(fx, fx+1, fx+2, fx+3, fx+4, fx+5, fx+6, fx+7);
var dirs = GetVectorPacket256(xs, SetAllVector256((float)y), camera);
var rayPacket256 = new RayPacket256(camera.PosPacket256, dirs);
var colors = TraceRay(rayPacket256, scene, 0);

// Writ into memory via xmm registers
var SoA = colors.FastTranspose();
var intSoA = SoA.ConvertToIntRGB();
var m0 = Avx.GetLowerHalf<int>(intSoA.Rs);
var m1 = Avx.GetLowerHalf<int>(intSoA.Gs);
var m2 = Avx.GetLowerHalf<int>(intSoA.Bs);
var m3 = Avx2.ExtractVector128(intSoA.Rs, 1);
var m4 = Avx2.ExtractVector128(intSoA.Gs, 1);
var m5 = Avx2.ExtractVector128(intSoA.Bs, 1);
var m0 = GetLowerHalf<int>(intSoA.Rs);
var m1 = GetLowerHalf<int>(intSoA.Gs);
var m2 = GetLowerHalf<int>(intSoA.Bs);
var m3 = ExtractVector128(intSoA.Rs, 1);
var m4 = ExtractVector128(intSoA.Gs, 1);
var m5 = ExtractVector128(intSoA.Bs, 1);

fixed (int* output = &rgb[x + stride])
{
Sse2.Store(output, m0);
Sse2.Store(output + 4, m1);
Sse2.Store(output + 8, m2);
Sse2.Store(output + 12, m3);
Sse2.Store(output + 16, m4);
Sse2.Store(output + 20, m5);
Store(output, m0);
Store(output + 4, m1);
Store(output + 8, m2);
Store(output + 12, m3);
Store(output + 16, m4);
Store(output + 20, m5);
}

/* Writ into memory via ymm registers
var SoA = colors.Transpose();
var intSoA = SoA.ConvertToIntRGB();
fixed (int* output = &rgb[x + stride])
{
Avx.Store(output, intSoA.xs);
Avx.Store(output + 8, intSoA.ys);
Avx.Store(output + 16, intSoA.zs);
Store(output, intSoA.xs);
Store(output + 8, intSoA.ys);
Store(output + 16, intSoA.zs);
}
*/

Expand All @@ -85,7 +88,7 @@ private Vector256<float> TestRay(RayPacket256 rayPacket256, Scene scene, int dep
var isect = MinIntersections(rayPacket256, scene);
if(isect.AllNullIntersections())
{
return Avx.SetZeroVector256<float>();
return SetZeroVector256<float>();
}
return isect.Distances;
}
Expand All @@ -100,14 +103,14 @@ private Intersections MinIntersections(RayPacket256 rayPacket256, Scene scene)
var orgIsect = objPacket256.Intersect(rayPacket256, index);
if (!orgIsect.AllNullIntersections())
{
var nullMinMask = Avx.Compare(mins.Distances, Intersections.Null.Distances, FloatComparisonMode.EqualOrderedNonSignaling);
var lessMinMask = Avx.Compare(mins.Distances, orgIsect.Distances, FloatComparisonMode.GreaterThanOrderedNonSignaling);
var minDis = Avx.BlendVariable(mins.Distances, orgIsect.Distances, Avx.Or(nullMinMask, lessMinMask));
var nullMinMask = Compare(mins.Distances, Intersections.Null.Distances, FloatComparisonMode.EqualOrderedNonSignaling);
var lessMinMask = Compare(mins.Distances, orgIsect.Distances, FloatComparisonMode.GreaterThanOrderedNonSignaling);
var minDis = BlendVariable(mins.Distances, orgIsect.Distances, Or(nullMinMask, lessMinMask));
mins.Distances = minDis;
var minIndex = Avx.BlendVariable(Avx.StaticCast<int, float>(mins.ThingIndex),
Avx.StaticCast<int, float>(Avx.SetAllVector256(index)),
Avx.Or(nullMinMask, lessMinMask)); //CSE
mins.ThingIndex = Avx.StaticCast<float, int>(minIndex);
var minIndex = BlendVariable(StaticCast<int, float>(mins.ThingIndex),
StaticCast<int, float>(SetAllVector256(index)),
Or(nullMinMask, lessMinMask)); //CSE
mins.ThingIndex = StaticCast<float, int>(minIndex);
}
index++;
}
Expand All @@ -129,16 +132,16 @@ private ColorPacket256 Shade(Intersections isect, RayPacket256 rayPacket256, Sce
}
}
/*
var intersectedNormals = Avx.SetZeroVector256<float>();
var intersectedNormals = SetZeroVector256<float>();
foreach (var pair in normals)
{
var index = pair.Key;
var normal = pair.value;
var posMask = Avx2.CompareEqual(isect.ThingIndex, Avx.SetAllVector256(index));
intersectedNormals = Avx.BlendVariable(intersectedNormals, normal, posMask);
var posMask = Avx2.CompareEqual(isect.ThingIndex, SetAllVector256(index));
intersectedNormals = BlendVariable(intersectedNormals, normal, posMask);
}
var reflectDirs = ds - Avx.Multiply(Avx.SetAllVector256(2f), VectorPacket256.DotProduct(intersectedNormals, ds)) * intersectedNormals;
var reflectDirs = ds - Multiply(SetAllVector256(2f), VectorPacket256.DotProduct(intersectedNormals, ds)) * intersectedNormals;
*/
//colors += GetNaturalColor();

Expand Down Expand Up @@ -173,8 +176,8 @@ private VectorPacket256 GetVectorPacket256(Vector256<float> x, Vector256<float>
float hightRate1 = Hight / 2.0f;
float hightRate2 = Hight * 2.0f;

var recenteredX = Avx.Divide(Avx.Subtract(x, Avx.SetAllVector256(widthRate1)), Avx.SetAllVector256(widthRate2));
var recenteredY = Avx.Subtract(Avx.SetZeroVector256<float>(), Avx.Divide(Avx.Subtract(y, Avx.SetAllVector256(hightRate1)), Avx.SetAllVector256(hightRate2)));
var recenteredX = Divide(Subtract(x, SetAllVector256(widthRate1)), SetAllVector256(widthRate2));
var recenteredY = Subtract(SetZeroVector256<float>(), Divide(Subtract(y, SetAllVector256(hightRate1)), SetAllVector256(hightRate2)));

var result = camera.ForwardPacket256 +
(recenteredX * camera.RightPacket256) +
Expand Down
2 changes: 2 additions & 0 deletions PacketTracer.csproj
View file
Expand Up @@ -5,8 +5,10 @@
<TargetFramework>netcoreapp2.1</TargetFramework>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<RuntimeIdentifier>win7-x64</RuntimeIdentifier>
<DebugType>pdbonly</DebugType>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="System.Runtime.Intrinsics.Experimental" Version="4.5.0-preview2-26406-04" />
</ItemGroup>

</Project>
13 changes: 7 additions & 6 deletions PlanePacket.cs
View file
@@ -1,4 +1,5 @@
using System.Runtime.Intrinsics.X86;
using static System.Runtime.Intrinsics.X86.Avx;
using System.Runtime.Intrinsics;

internal class PlanePacket256: ObjectPacket256
Expand All @@ -8,17 +9,17 @@ internal class PlanePacket256: ObjectPacket256

public PlanePacket256(Plane plane): base(plane.Surface)
{
Norms = new VectorPacket256(Avx.SetAllVector256(plane.Norm.X), Avx.SetAllVector256(plane.Norm.Y), Avx.SetAllVector256(plane.Norm.Z));
Offsets = Avx.SetAllVector256(plane.Offset);
Norms = new VectorPacket256(SetAllVector256(plane.Norm.X), SetAllVector256(plane.Norm.Y), SetAllVector256(plane.Norm.Z));
Offsets = SetAllVector256(plane.Offset);
}

public override Intersections Intersect(RayPacket256 rayPacket256, int index)
{
var denom = VectorPacket256.DotProduct(Norms, rayPacket256.Dirs);
var dist = Avx.Divide(VectorPacket256.DotProduct(Norms, rayPacket256.Starts), Avx.Subtract(Avx.SetZeroVector256<float>(), denom));
var gtMask = Avx.Compare(denom, Avx.SetZeroVector256<float>(), FloatComparisonMode.GreaterThanOrderedNonSignaling);
var reslut = Avx.Or(Avx.And(gtMask, Avx.SetAllVector256(Intersections.NullValue)), Avx.AndNot(gtMask, dist));
return new Intersections(reslut, Avx.SetAllVector256<int>(index));
var dist = Divide(VectorPacket256.DotProduct(Norms, rayPacket256.Starts), Subtract(SetZeroVector256<float>(), denom));
var gtMask = Compare(denom, SetZeroVector256<float>(), FloatComparisonMode.GreaterThanOrderedNonSignaling);
var reslut = Or(And(gtMask, SetAllVector256(Intersections.NullValue)), AndNot(gtMask, dist));
return new Intersections(reslut, SetAllVector256<int>(index));
}

public override VectorPacket256 Normal(VectorPacket256 pos)
Expand Down
23 changes: 12 additions & 11 deletions SpherePacket.cs
View file
@@ -1,4 +1,5 @@
using System.Runtime.Intrinsics.X86;
using static System.Runtime.Intrinsics.X86.Avx;
using System.Runtime.Intrinsics;

internal class SpherePacket256: ObjectPacket256
Expand All @@ -8,32 +9,32 @@ internal class SpherePacket256: ObjectPacket256

public SpherePacket256(Sphere sphere): base(sphere.Surface)
{
Centers = new VectorPacket256(Avx.SetAllVector256(sphere.Center.X), Avx.SetAllVector256(sphere.Center.Y), Avx.SetAllVector256(sphere.Center.Z));
Radiuses = Avx.SetAllVector256(sphere.Radius);
Centers = new VectorPacket256(SetAllVector256(sphere.Center.X), SetAllVector256(sphere.Center.Y), SetAllVector256(sphere.Center.Z));
Radiuses = SetAllVector256(sphere.Radius);
}

public override Intersections Intersect(RayPacket256 rayPacket256, int index)
{
var intersections = Intersections.Null;
var eo = Centers - rayPacket256.Starts;
var v = VectorPacket256.DotProduct(eo, rayPacket256.Dirs);
var zeroVMask = Avx.Compare(v, Avx.SetZeroVector256<float>(), FloatComparisonMode.LessThanOrderedNonSignaling);
var zero = Avx.SetZeroVector256<int>();
var zeroVMask = Compare(v, SetZeroVector256<float>(), FloatComparisonMode.LessThanOrderedNonSignaling);
var zero = SetZeroVector256<int>();
var allOneMask = Avx2.CompareEqual(zero, zero);
if(Avx.TestC(zeroVMask, Avx.StaticCast<int, float>(allOneMask)))
if(TestC(zeroVMask, StaticCast<int, float>(allOneMask)))
{
return intersections; // Null Intersections
}

var discs = Avx.Subtract(Avx.Multiply(Radiuses, Radiuses), Avx.Subtract(VectorPacket256.DotProduct(eo, eo), Avx.Multiply(v, v)));
var dists = Avx.Sqrt(discs);
var zeroDiscMask = Avx.Compare(discs, Avx.SetZeroVector256<float>(), FloatComparisonMode.LessThanOrderedNonSignaling);
var discs = Subtract(Multiply(Radiuses, Radiuses), Subtract(VectorPacket256.DotProduct(eo, eo), Multiply(v, v)));
var dists = Sqrt(discs);
var zeroDiscMask = Compare(discs, SetZeroVector256<float>(), FloatComparisonMode.LessThanOrderedNonSignaling);

var nullInter = Avx.SetAllVector256(Intersections.NullValue);
var filter = Avx.BlendVariable(dists, nullInter, Avx.Or(zeroVMask, zeroDiscMask));
var nullInter = SetAllVector256(Intersections.NullValue);
var filter = BlendVariable(dists, nullInter, Or(zeroVMask, zeroDiscMask));

intersections.Distances = filter;
intersections.ThingIndex = Avx.SetAllVector256<int>(index);
intersections.ThingIndex = SetAllVector256<int>(index);
return intersections;
}

Expand Down

0 comments on commit a875409

Please sign in to comment.