public static void NonexistentReferencesHeapMemoryTest()
{
using (var memory = new HeapResizableDirectMemory(UInt64UnitedMemoryLinks.DefaultLinksSizeStep))
using (var memoryAdapter = new UInt64UnitedMemoryLinks(memory, UInt64UnitedMemoryLinks.DefaultLinksSizeStep))
{
memoryAdapter.TestNonexistentReferences();
}
}
public static void BasicHeapMemoryTest()
{
using (var memory = new HeapResizableDirectMemory(UInt64UnitedMemoryLinks.DefaultLinksSizeStep))
using (var memoryAdapter = new UInt64UnitedMemoryLinks(memory, UInt64UnitedMemoryLinks.DefaultLinksSizeStep))
{
memoryAdapter.TestBasicMemoryOperations();
}
}
private static void Using <TLink>(Action <ILinks <TLink> > action)
{
using (var dataMemory = new HeapResizableDirectMemory())
using (var indexMemory = new HeapResizableDirectMemory())
using (var memory = new SplitMemoryLinks <TLink>(dataMemory, indexMemory))
{
action(memory);
}
}
private static void UsingWithExternalReferences <TLink>(Action <ILinks <TLink> > action)
{
var contants = new LinksConstants <TLink>(enableExternalReferencesSupport: true);
using (var dataMemory = new HeapResizableDirectMemory())
using (var indexMemory = new HeapResizableDirectMemory())
using (var memory = new SplitMemoryLinks <TLink>(dataMemory, indexMemory, SplitMemoryLinks <TLink> .DefaultLinksSizeStep, contants))
{
action(memory);
}
}
public void CorrectMemoryReallocationTest()
{
using var heapMemory = new HeapResizableDirectMemory();
var value1 = GetLastByte(heapMemory);
heapMemory.ReservedCapacity *= 2;
var value2 = GetLastByte(heapMemory);
Assert.Equal(value1, value2);
Assert.Equal(0, value1);
}
public static void Setup()
{
var dataMemory = new HeapResizableDirectMemory();
var indexMemory = new HeapResizableDirectMemory();
_splitMemory = new SplitMemoryLinks <uint>(dataMemory, indexMemory);
_splitMemoryLinks = _splitMemory.DecorateWithAutomaticUniquenessAndUsagesResolution();
var memory = new HeapResizableDirectMemory();
_unitedMemory = new UnitedMemoryLinks <uint>(memory);
_unitedMemoryLinks = _unitedMemory.DecorateWithAutomaticUniquenessAndUsagesResolution();
}
public Patterns(string sourceImagePath)
{
_sourceImagePath = Path.GetFullPath(sourceImagePath);
_image = new MagickImage(sourceImagePath);
_pixels = _image.GetPixels();
_linksPath = Path.ChangeExtension(_sourceImagePath, ".links");
var memory = new HeapResizableDirectMemory(); //new FileMappedResizableDirectMemory(_linksPath);
var constants = new LinksConstants <ulong>(enableExternalReferencesSupport: true);
_links = new UInt64Links(new UInt64UnitedMemoryLinks(memory, UInt64UnitedMemoryLinks.DefaultLinksSizeStep, constants, Platform.Data.Doublets.Memory.IndexTreeType.SizedAndThreadedAVLBalancedTree));
_addressToRawNumberConverter = new AddressToRawNumberConverter <ulong>();
_rawNumberToAddressConverter = new RawNumberToAddressConverter <ulong>();
_totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter <ulong>(_links);
_linkFrequenciesCache = new LinkFrequenciesCache <ulong>(_links, _totalSequenceSymbolFrequencyCounter);
_index = new CachedFrequencyIncrementingSequenceIndex <ulong>(_linkFrequenciesCache);
_linkToItsFrequencyNumberConverter = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter <ulong>(_linkFrequenciesCache);
_sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(_links, _linkToItsFrequencyNumberConverter);
_optimalVariantConverter = new OptimalVariantConverter <ulong>(_links, _sequenceToItsLocalElementLevelsConverter);
}
private ulong Calculate(int start, int steps)
{
const int mb4 = 4 * 1024 * 1024;
using (var memory = new HeapResizableDirectMemory(mb4))
using (var memoryManager = new UInt64LinksMemoryManager(memory))
using (var links = new UInt64Links(memoryManager))
{
ulong[] digits = new ulong[10];
SetPoints(links, digits);
SetSteps(links, digits);
ulong current = digits[start];
var counter = new Counter();
CalculateCore(links, current, steps, counter);
return counter.Count;
}
}
public static void SavedSequencesOptimizationTest()
{
LinksConstants <ulong> constants = new LinksConstants <ulong>((1, long.MaxValue), (long.MaxValue + 1UL, ulong.MaxValue));
using (var memory = new HeapResizableDirectMemory())
using (var disposableLinks = new UInt64UnitedMemoryLinks(memory, UInt64UnitedMemoryLinks.DefaultLinksSizeStep, constants, IndexTreeType.Default))
{
var links = new UInt64Links(disposableLinks);
var root = links.CreatePoint();
//var numberToAddressConverter = new RawNumberToAddressConverter<ulong>();
var addressToNumberConverter = new AddressToRawNumberConverter <ulong>();
var unicodeSymbolMarker = links.GetOrCreate(root, addressToNumberConverter.Convert(1));
var unicodeSequenceMarker = links.GetOrCreate(root, addressToNumberConverter.Convert(2));
var totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter <ulong>(links);
var linkFrequenciesCache = new LinkFrequenciesCache <ulong>(links, totalSequenceSymbolFrequencyCounter);
var index = new CachedFrequencyIncrementingSequenceIndex <ulong>(linkFrequenciesCache);
var linkToItsFrequencyNumberConverter = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter <ulong>(linkFrequenciesCache);
var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(links, linkToItsFrequencyNumberConverter);
var optimalVariantConverter = new OptimalVariantConverter <ulong>(links, sequenceToItsLocalElementLevelsConverter);
var walker = new RightSequenceWalker <ulong>(links, new DefaultStack <ulong>(), (link) => constants.IsExternalReference(link) || links.IsPartialPoint(link));
var unicodeSequencesOptions = new SequencesOptions <ulong>()
{
UseSequenceMarker = true,
SequenceMarkerLink = unicodeSequenceMarker,
UseIndex = true,
Index = index,
LinksToSequenceConverter = optimalVariantConverter,
Walker = walker,
UseGarbageCollection = true
};
var unicodeSequences = new Sequences.Sequences(new SynchronizedLinks <ulong>(links), unicodeSequencesOptions);
// Create some sequences
var strings = _loremIpsumExample.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
var arrays = strings.Select(x => x.Select(y => addressToNumberConverter.Convert(y)).ToArray()).ToArray();
for (int i = 0; i < arrays.Length; i++)
{
unicodeSequences.Create(arrays[i].ShiftRight());
}
var linksCountAfterCreation = links.Count();
// get list of sequences links
// for each sequence link
// create new sequence version
// if new sequence is not the same as sequence link
// delete sequence link
// collect garbadge
unicodeSequences.CompactAll();
var linksCountAfterCompactification = links.Count();
Assert.True(linksCountAfterCompactification < linksCountAfterCreation);
}
}
private static byte GetLastByte(HeapResizableDirectMemory heapMemory)
{
var pointer1 = (void *)heapMemory.Pointer;
return(*((byte *)pointer1 + heapMemory.ReservedCapacity - 1));
}
