/// <summary> /// This method used to save accounting journal entry /// </summary> /// <param name="journalEntryDetails"></param> public void SaveAccountingJournalEntry(JournalEntryAc journalEntryDetails) { try { foreach (var entryDetails in journalEntryDetails.JournalEntryCollection) { if (entryDetails.LedgerId != 0 && (entryDetails.DebitAmount != 0 || entryDetails.CreditAmount != 0)) { var doubleEntry = new DoubleEntry { Debit = entryDetails.DebitAmount, Credit = entryDetails.CreditAmount, Description = entryDetails.Description, LedgerId = entryDetails.LedgerId, TransactionDate = journalEntryDetails.JournalDate.ToLocalTime(), ActivityName = StringConstants.JournalEntry, CreatedDateTime = DateTime.UtcNow }; _accountEntryContext.Add(doubleEntry); _accountEntryContext.SaveChanges(); } } } catch (Exception ex) { _errorLog.LogException(ex); throw; } }
public static DoubleEntry[] CreateDoubleChunk(int count, DateTime?start = null, double percentOfFill = 1.0, int ticksIntervalMs = 100) { var data = new DoubleEntry[(int)(count * percentOfFill)]; var ticks = (start ?? DateTime.Now).Ticks; var ticksStep = TimeSpan.FromMilliseconds(ticksIntervalMs).Ticks; data[0].ticks = ticks; data[0].value = random.NextDouble() * 100.0; for (int i = 1, j = 1; i < count && j < data.Length; i++) { ticks += ticksStep; if (!(random.NextDouble() + percentOfFill >= 1.0)) { continue; } data[j].ticks = ticks; data[j].value = random.NextDouble() * 100.0; j++; } return(data); }
public void RavenNominaleTest() { const int size = 16 * Mem.KB; var count = size / sizeof(DoubleEntry); var chunk = Factory.CreateDoubleChunk(count); var buffer = new byte[size]; var result = new DoubleEntry[count]; fixed(byte *o = buffer) { int compressedSize; fixed(DoubleEntry *i = chunk) { var pi = (byte *)i; var po = o; compressedSize = Lz4Raven.Encode64(ref pi, ref po, size, (int)Lz4Raven.MaximumOutputLength(size)); } Console.WriteLine("Compression ratio: x {0}", size / (double)compressedSize); fixed(DoubleEntry *r = result) Lz4Raven.Decode64(o, compressedSize, (byte *)r, size, true); } result.Check(chunk); }
public void NominaleTest() { const int size = 16 * Mem.KB; var count = size / sizeof(DoubleEntry); var chunk = Factory.CreateDoubleChunk(count); var buffer = new byte[size]; var result = new DoubleEntry[count]; fixed(byte *o = buffer) { int compressedSize; fixed(DoubleEntry *i = chunk) { var pi = (byte *)i; var po = o; compressedSize = Lz4.LZ4_compress_fast(pi, po, size, (int)Lz4.MaximumOutputLength(size), 1); } Console.WriteLine("Compression ratio: x {0}", size / (double)compressedSize); fixed(DoubleEntry *r = result) { var ip = o; var op = (byte *)r; Lz4.LZ4_decompress_fast(ref ip, ref op, compressedSize); } } result.Check(chunk); }
private static void TestCursor <TEntry, T>( Func <DoubleEntry[], TEntry[]> convert, Func <TEntry, T> getValue, Func <TEntry[], IColumnCursor <T> > factory, T defaultValue = default(T)) where T : struct { const int iterations = 5; var chunk = new DoubleEntry[0] .Add(0, 12.2) .Add(4, 15.2) .Add(5, 16.2) .Add(6, 13.2) .Add(7, 14.2); var convertedChunk = convert(chunk); var cursor = factory(convertedChunk); // Test MoveNext for (var i = 0; i < iterations; i++) { Assert.AreEqual(getValue(convertedChunk[0]), cursor.GetNext(0)); Assert.AreEqual(getValue(convertedChunk[0]), cursor.GetNext(1)); Assert.AreEqual(getValue(convertedChunk[0]), cursor.GetNext(2)); Assert.AreEqual(getValue(convertedChunk[1]), cursor.GetNext(4)); Assert.AreEqual(getValue(convertedChunk[2]), cursor.GetNext(5)); Assert.AreEqual(getValue(convertedChunk[3]), cursor.GetNext(6)); Assert.AreEqual(getValue(convertedChunk[4]), cursor.GetNext(7)); Assert.AreEqual(getValue(convertedChunk[4]), cursor.GetNext(8)); Assert.AreEqual(getValue(convertedChunk[4]), cursor.GetNext(9)); cursor.Reset(); } cursor.Dispose(); chunk.Set(0, 1, 12.2); cursor = factory(convert(chunk)); for (var i = 0; i < iterations; i++) { Assert.AreEqual(defaultValue, cursor.GetNext(0)); Assert.AreEqual(getValue(convertedChunk[0]), cursor.GetNext(1)); Assert.AreEqual(getValue(convertedChunk[3]), cursor.GetNext(6)); Assert.AreEqual(getValue(convertedChunk[4]), cursor.GetNext(7)); cursor.Reset(); } cursor.Dispose(); }
public void RavenCompressWithLowerBlockTest() { const int size = 16 * Mem.KB; const int writeBlockSize = 1 * Mem.KB; var count = size / sizeof(DoubleEntry); var chunk = Factory.CreateDoubleChunk(count); var buffer = new byte[size]; var result = new DoubleEntry[count]; fixed(byte *o = buffer) { var compressedSize = 0; fixed(DoubleEntry *i = chunk) { var pi = (byte *)i; var pEnd = pi + size; var po = o; while (pi < pEnd) { var wrote = Lz4Raven.Encode64(ref pi, ref po, (int)(pEnd - pi), size, writeBlockSize, 1); //Assert.LessOrEqual(wrote, writeBlockSize); compressedSize += wrote; } } Console.WriteLine("Compression ratio: x {0}", size / (double)compressedSize); fixed(DoubleEntry *r = result) { var iPtr = o; var oPtr = (byte *)r; var inputLength = compressedSize; var wrote = 0; while (wrote < size) { wrote += Lz4Raven.Decode64(ref iPtr, inputLength, ref oPtr, size - wrote, writeBlockSize); } } } result.Check(chunk); }
public void RavenUncompressWithLowerBlocksTest() { const int size = 16 * Mem.KB; const int writeBlockSize = 4 * Mem.KB; var count = size / sizeof(DoubleEntry); var chunk = Factory.CreateDoubleChunk(count); var buffer = new byte[size]; var result = new DoubleEntry[count]; fixed(byte *o = buffer) { int compressedSize; fixed(DoubleEntry *i = chunk) { var pi = (byte *)i; var po = o; compressedSize = Lz4Raven.Encode64(ref pi, ref po, size, (int)Lz4Raven.MaximumOutputLength(size)); } Console.WriteLine("Compression ratio: x {0}", size / (double)compressedSize); fixed(DoubleEntry *r = result) { var iPtr = o; var oPtr = (byte *)r; var inputLength = compressedSize; var wrote = 0; while (wrote < size) { wrote += Lz4Raven.Decode64(ref iPtr, inputLength, ref oPtr, size - wrote, writeBlockSize); } } } result.Check(chunk); }
public static Int64Entry ToInt64(this DoubleEntry entry) { return(new Int64Entry { ticks = entry.ticks, value = (long)entry.value }); }
public static Int32Entry ToInt32(this DoubleEntry entry) { return(new Int32Entry { ticks = entry.ticks, value = (int)entry.value }); }
public static FloatEntry ToFloat(this DoubleEntry entry) { return(new FloatEntry { ticks = entry.ticks, value = (float)entry.value }); }
public void RavenUncompressComparePerf() { const int size = 4 * Mem.KB; var readSizes = new [] { 1, 2, 4, 8, 16 }; const int iterations = 10000; var count = size / sizeof(DoubleEntry); var chunk = Factory.CreateDoubleChunk(count); var buffer = new byte[size]; var result = new DoubleEntry[count]; fixed(byte *o = buffer) { int compressedSize; fixed(DoubleEntry *i = chunk) { var pi = (byte *)i; var po = o; compressedSize = Lz4Raven.Encode64(ref pi, ref po, size, (int)Lz4Raven.MaximumOutputLength(size)); } Console.WriteLine("Compression ratio: x {0}", size / (double)compressedSize); fixed(DoubleEntry *r = result) { Lz4Raven.Decode64(o, compressedSize, (byte *)r, size, true); // Jitter purpose for (var i = 0; i < 10; i++) { var iPtr = o; var oPtr = (byte *)r; var writeBlockSize = readSizes[0] * Mem.KB; var wrote = 0; while (wrote < size) { wrote += Lz4Raven.Decode64(ref iPtr, compressedSize, ref oPtr, size - wrote, writeBlockSize); } } var sw = Stopwatch.StartNew(); for (var i = 0; i < iterations; i++) { Lz4Raven.Decode64(o, compressedSize, (byte *)r, size, true); } sw.Stop(); Console.WriteLine("Match: {0} µs", sw.Elapsed.TotalMilliseconds / iterations * 1e3); result.Check(chunk); for (var j = 0; j < readSizes.Length; j++) { var writeBlockSize = readSizes[j] * Mem.KB; sw = Stopwatch.StartNew(); for (var i = 0; i < iterations; i++) { var iPtr = o; var oPtr = (byte *)r; var wrote = 0; while (wrote < size) { wrote += Lz4Raven.Decode64(ref iPtr, compressedSize, ref oPtr, size - wrote, writeBlockSize); } } sw.Stop(); Console.WriteLine("Size {0} KB: {1} µs", readSizes[j], sw.Elapsed.TotalMilliseconds / iterations * 1e3); result.Check(chunk); } } } }