Misaki/Misaki.HighPerformance
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Vector type in SPMD to total of load vector size * lane width of number into memory for simd calculation.

Browse Source
This commit is contained in:
Misaki
2026-02-13 21:47:05 +09:00
parent 75d33d0763
commit 4f964b2d2a
22 changed files with 3682 additions and 447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

420
Misaki.HighPerformance.Mathematics.SPMD/Templates/Vector{T}Helper.ttinclude Normal file
View File

@@ -0,0 +1,420 @@
<#@ import namespace="System.Text" #>
<#+
private const string TLane = "TLane";
private const string TNumber = "TNumber";
private string TLaneRestrictions = $@"where {TLane} : ISPMD<{TLane}, {TNumber}>";
private string TNumberRestrictions = $@"where {TNumber} : unmanaged, INumber<{TNumber}>, IBinaryNumber<{TNumber}>, IMinMaxValue<{TNumber}>, IBitwiseOperators<{TNumber}, {TNumber}, {TNumber}>";
private int[] dimensions = new int[] { 2, 3, 4 };
private char[] components = new char[] { 'x', 'y', 'z', 'w' };
public string Indent(string str, int spaces)
{
var indent = new string(' ', spaces);
return indent + str;
}
private string ForEachDimension(int maxDimension, int indentation, string spliter, Action<int, StringBuilder> action, bool spliterOnFirst = true)
{
var sb = new StringBuilder();
for (var dimension = 0; dimension < maxDimension; dimension++)
{
if ((dimension > 0 || spliterOnFirst) && indentation > 0)
{
sb.Append(new string(' ', indentation));
}
action(dimension, sb);
if (dimension < maxDimension - 1)
{
sb.Append(spliter);
}
}
return sb.ToString();
}
public StringBuilder GenerateVectorType(int dimension)
{
var sb = new StringBuilder();
var typeName = $"Vector{dimension}<{TLane}, {TNumber}>";
sb.AppendLine(@$"
public unsafe struct {typeName} : IEquatable<{typeName}>
{TLaneRestrictions}
{TNumberRestrictions}
{{
{ForEachDimension(dimension, 4, Environment.NewLine, (dim, sb) => sb.Append($"public {TLane} {components[dim]};"))}
public static {typeName} Zero
{{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{{
return new {typeName}
{{
{ForEachDimension(dimension, 16, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = {TLane}.Zero,"))}
}};
}}
}}
public static {typeName} One
{{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{{
return new {typeName}
{{
{ForEachDimension(dimension, 16, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = {TLane}.One,"))}
}};
}}
}}
public {TLane} this[int index]
{{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{{
RangeCheck(index);
return Unsafe.Add(ref x, index);
}}
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[Conditional(""ENABLE_COLLECTION_CHECKS"")]
private static void RangeCheck(int index)
{{
if (index < 0 || index >= {dimension})
{{
throw new IndexOutOfRangeException($""Index {{index}} is out of range for Vector2."");
}}
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Store({TNumber}* pDst)
{{
var width = {TLane}.LaneWidth;
{ForEachDimension(dimension, 8, Environment.NewLine, (dim, sb) => sb.Append($"var {components[dim]} = stackalloc {TNumber}[width];"))}
{ForEachDimension(dimension, 8, Environment.NewLine, (dim, sb) => sb.Append($"this.{components[dim]}.Store({components[dim]});"))}
for (var i = 0; i < width; i++)
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"pDst[i * 2 + {dim}] = {components[dim]}[i];"))}
}}
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Store(ref {TNumber} dst)
{{
Store(({TNumber}*)Unsafe.AsPointer(ref dst));
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Store({ForEachDimension(dimension, 1, ", ", (dim, sb) => sb.Append($"{TNumber}* p{components[dim]}"), false)})
{{
{ForEachDimension(dimension, 8, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]}.Store(p{components[dim]});"))}
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Store({ForEachDimension(dimension, 1, ", ", (dim, sb) => sb.Append($"ref {TNumber} {components[dim]}"), false)})
{{
{ForEachDimension(dimension, 8, Environment.NewLine, (dim, sb) => sb.Append($"this.{components[dim]}.Store(ref {components[dim]});"))}
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator +(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} + right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator +(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} + lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator +({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane + vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator -(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} - right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator -(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} - lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator -({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane - vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator *(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} * right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator *(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} * lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator *({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane * vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator /(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} / right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator /(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} / lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator /({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane / vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator ==(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} == right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator ==(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} == lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator ==({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane == vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator !=(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} != right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator !=(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} != lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator !=({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane != vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator >(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} > right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator >(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} > lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator >({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane > vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator >=(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} >= right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator >=(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} >= lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator >=({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane >= vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator <(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} < right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator <(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} < lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator <({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane < vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator <=(in {typeName} left, in {typeName} right)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = left.{components[dim]} <= right.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator <=(in {typeName} vector, {TLane} lane)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = vector.{components[dim]} <= lane,"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static {typeName} operator <=({TLane} lane, in {typeName} vector)
{{
return new {typeName}
{{
{ForEachDimension(dimension, 12, Environment.NewLine, (dim, sb) => sb.Append($"{components[dim]} = lane <= vector.{components[dim]},"))}
}};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public readonly bool Equals({typeName} other)
{{
return {ForEachDimension(dimension, 0, " && ", (dim, sb) => sb.Append($"this.{components[dim]}.Equals(other.{components[dim]})"), false)};
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override readonly bool Equals(object? obj)
{{
return obj is {typeName} other && Equals(other);
}}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode()
{{
throw new NotImplementedException();
}}
}}");
return sb;
}
#>