Dotnet/ExaArray
Dotnet/ExaArray
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed optimization. Thanks @jkotas.

Browse Source 
https://github.com/dotnet/runtime/issues/12221#issuecomment-665815891
This commit is contained in:
Thorsten Sommer 2020-07-30 19:53:01 +02:00
parent 88aa920231
commit 62aa37d31f
2 changed files with 48 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ExaArray/ExaArray.csproj
View File

@ -10,9 +10,9 @@
<PackageProjectUrl>https://code.tsommer.org/thorsten/ExaArray</PackageProjectUrl> <PackageProjectUrl>https://code.tsommer.org/thorsten/ExaArray</PackageProjectUrl>
<PackageLicenseExpression>BSD-3-Clause</PackageLicenseExpression> <PackageLicenseExpression>BSD-3-Clause</PackageLicenseExpression>
<RepositoryUrl>https://code.tsommer.org/thorsten/ExaArray</RepositoryUrl> <RepositoryUrl>https://code.tsommer.org/thorsten/ExaArray</RepositoryUrl>
<PackageVersion>1.1.0</PackageVersion> <PackageVersion>1.1.1</PackageVersion>
<AssemblyVersion>1.1.0</AssemblyVersion> <AssemblyVersion>1.1.1</AssemblyVersion>
<FileVersion>1.1.0</FileVersion> <FileVersion>1.1.1</FileVersion>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' "> <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">

70
ExaArray/ExaArray1D.cs
View File

@ -33,9 +33,6 @@ namespace Exa
/// </summary> /// </summary>
public const ulong MAX_NUMBER_ELEMENTS_PERFORMANCE = 1_152_921_504_606_850_000; public const ulong MAX_NUMBER_ELEMENTS_PERFORMANCE = 1_152_921_504_606_850_000;
private readonly ulong maxCapacityArray;
private readonly ulong maxNumberElements;
/// <summary> /// <summary>
/// Gets the configured optimization strategy. /// Gets the configured optimization strategy.
/// </summary> /// </summary>
@ -44,24 +41,21 @@ namespace Exa
// Chunk storage: // Chunk storage:
private T[][] chunks = new T[1][]; private T[][] chunks = new T[1][];
// Max. array and chunk capacity:
private readonly uint maxArrayCapacity;
// Max. number elements:
private readonly ulong maxElements;
/// <summary> /// <summary>
/// Creates an empty one-dimensional exa-scale array. /// Creates an empty one-dimensional exa-scale array.
/// </summary> /// </summary>
public ExaArray1D(Strategy strategy = Strategy.MAX_PERFORMANCE) public ExaArray1D(Strategy strategy = Strategy.MAX_PERFORMANCE)
{ {
this.OptimizationStrategy = strategy;
this.chunks[0] = new T[0]; this.chunks[0] = new T[0];
this.OptimizationStrategy = strategy;
if (this.OptimizationStrategy == Strategy.MAX_PERFORMANCE) this.maxElements = this.OptimizationStrategy == Strategy.MAX_PERFORMANCE ? MAX_NUMBER_ELEMENTS_PERFORMANCE : MAX_NUMBER_ELEMENTS;
{ this.maxArrayCapacity = this.OptimizationStrategy == Strategy.MAX_PERFORMANCE ? MAX_CAPACITY_ARRAY_PERFORMANCE : MAX_CAPACITY_ARRAY;
this.maxCapacityArray = MAX_CAPACITY_ARRAY_PERFORMANCE;
this.maxNumberElements = MAX_NUMBER_ELEMENTS_PERFORMANCE;
}
else
{
this.maxCapacityArray = MAX_CAPACITY_ARRAY;
this.maxNumberElements = MAX_NUMBER_ELEMENTS;
}
} }
/// <summary> /// <summary>
@ -81,15 +75,15 @@ namespace Exa
/// <c>extendBy</c> argument exceeds the limit of 4,607,183,514,018,780,000 elements.</exception> /// <c>extendBy</c> argument exceeds the limit of 4,607,183,514,018,780,000 elements.</exception>
public void Extend(ulong extendBy = 1) public void Extend(ulong extendBy = 1)
{ {
if(extendBy > this.maxNumberElements || this.Length + extendBy >= this.maxNumberElements) if (extendBy > this.maxElements || this.Length + extendBy >= this.maxElements)
throw new ArgumentOutOfRangeException($"It is not possible to extend more than {this.maxNumberElements} elements."); throw new ArgumentOutOfRangeException($"It is not possible to extend more than {this.maxElements} elements.");
this.Length += extendBy; this.Length += extendBy;
var availableInCurrentChunk = this.maxCapacityArray - (ulong) (this.chunks[^1]?.Length ?? 0); var availableInCurrentChunk = this.maxArrayCapacity - (ulong) (this.chunks[^1]?.Length ?? 0);
if (extendBy >= (ulong)availableInCurrentChunk) if (extendBy >= (ulong)availableInCurrentChunk)
{ {
// Extend the current chunk to its max: // Extend the current chunk to its max:
var extendedInner = new T[this.maxCapacityArray]; var extendedInner = new T[this.maxArrayCapacity];
Array.Copy(this.chunks[^1], extendedInner, this.chunks[^1].Length); Array.Copy(this.chunks[^1], extendedInner, this.chunks[^1].Length);
this.chunks[^1] = extendedInner; this.chunks[^1] = extendedInner;
@ -102,7 +96,7 @@ namespace Exa
do do
{ {
ulong allocating = leftOver >= this.maxCapacityArray ? this.maxCapacityArray : leftOver; ulong allocating = leftOver >= this.maxArrayCapacity ? this.maxArrayCapacity : leftOver;
leftOver -= allocating; leftOver -= allocating;
// First, we allocate space for the new chunk: // First, we allocate space for the new chunk:
@ -145,21 +139,45 @@ namespace Exa
{ {
get get
{ {
if(index >= this.maxNumberElements) if(index >= this.maxElements)
throw new IndexOutOfRangeException(); throw new IndexOutOfRangeException();
int chunkIndex = (int) (index / this.maxCapacityArray); int chunkIndex = -1;
int elementIndex = (int) (index - (ulong) chunkIndex * this.maxCapacityArray); int elementIndex = -1;
switch (this.OptimizationStrategy)
{
case Strategy.MAX_PERFORMANCE:
chunkIndex = (int) (index / MAX_CAPACITY_ARRAY_PERFORMANCE);
elementIndex = (int) (index - (ulong) chunkIndex * MAX_CAPACITY_ARRAY_PERFORMANCE);
break;
case Strategy.MAX_ELEMENTS:
chunkIndex = (int) (index / MAX_CAPACITY_ARRAY);
elementIndex = (int) (index - (ulong) chunkIndex * MAX_CAPACITY_ARRAY);
break;
}
return this.chunks[chunkIndex][elementIndex]; return this.chunks[chunkIndex][elementIndex];
} }
set set
{ {
if(index >= this.maxNumberElements) if(index >= this.maxElements)
throw new IndexOutOfRangeException(); throw new IndexOutOfRangeException();
int chunkIndex = (int) (index / this.maxCapacityArray); int chunkIndex = -1;
int elementIndex = (int) (index - (ulong) chunkIndex * this.maxCapacityArray); int elementIndex = -1;
switch (this.OptimizationStrategy)
{
case Strategy.MAX_PERFORMANCE:
chunkIndex = (int) (index / MAX_CAPACITY_ARRAY_PERFORMANCE);
elementIndex = (int) (index - (ulong) chunkIndex * MAX_CAPACITY_ARRAY_PERFORMANCE);
break;
case Strategy.MAX_ELEMENTS:
chunkIndex = (int) (index / MAX_CAPACITY_ARRAY);
elementIndex = (int) (index - (ulong) chunkIndex * MAX_CAPACITY_ARRAY);
break;
}
if (chunkIndex >= this.chunks.Length || elementIndex >= this.chunks[chunkIndex].Length) if (chunkIndex >= this.chunks.Length || elementIndex >= this.chunks[chunkIndex].Length)
throw new IndexOutOfRangeException(); throw new IndexOutOfRangeException();