/// <summary>
///
/// </summary>
/// <param name="memory"></param>
/// <param name="readValueType"></param>
/// <returns></returns>
private static TagHisValue <T> DeCompressDataBlockRawValue <T>(MarshalMemoryBlock memory, byte readValueType)
{
var ctype = memory.ReadByte();
var tp = CompressUnitManager2.Manager.GetCompress(ctype);
if (tp != null)
{
return(tp.DeCompressRawValue <T>(memory, 1, readValueType));
}
return(TagHisValue <T> .Empty);
}
/// <summary>
///
/// </summary>
/// <param name="memory"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="timeTick"></param>
/// <param name="result"></param>
private static void DeCompressDataBlockAllValue <T>(MarshalMemoryBlock memory, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult <T> result)
{
//MarshalMemoryBlock target = new MarshalMemoryBlock(memory.Length);
//读取压缩类型
var ctype = memory.ReadByte();
var tp = CompressUnitManager2.Manager.GetCompress(ctype);
if (tp != null)
{
tp.DeCompressAllValue(memory, 1, startTime, endTime, timeTick, result);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="memory"></param>
/// <param name="datatime"></param>
/// <param name="timeTick"></param>
/// <param name="type"></param>
/// <param name="result"></param>
private static void DeCompressDataBlockValue <T>(MarshalMemoryBlock memory, List <DateTime> datatime, int timeTick, QueryValueMatchType type, HisQueryResult <T> result, Func <byte, object> ReadOtherDatablockAction)
{
//MarshalMemoryBlock target = new MarshalMemoryBlock(memory.Length);
//读取压缩类型
var ctype = memory.ReadByte();
var tp = CompressUnitManager2.Manager.GetCompress(ctype);
if (tp != null)
{
tp.DeCompressValue <T>(memory, 1, datatime, timeTick, type, result, ReadOtherDatablockAction);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="memory"></param>
/// <param name="datatime"></param>
/// <param name="timeTick"></param>
/// <param name="type"></param>
/// <returns></returns>
private static object DeCompressDataBlockValue <T>(MarshalMemoryBlock memory, DateTime datatime, int timeTick, QueryValueMatchType type, Func <byte, object> ReadOtherDatablockAction)
{
//MarshalMemoryBlock target = new MarshalMemoryBlock(memory.Length);
//读取压缩类型
var ctype = memory.ReadByte();
var tp = CompressUnitManager2.Manager.GetCompress(ctype);
if (tp != null)
{
return(tp.DeCompressValue <T>(memory, 1, datatime, timeTick, type, ReadOtherDatablockAction));
}
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="block"></param>
public void Release(MarshalMemoryBlock block)
{
lock (mFreePools)
{
var size = (int)block.AllocSize;
if (mFreePools.ContainsKey(size))
{
var vv = mFreePools[size];
vv.Enqueue(block);
block.Clear();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="memory"></param>
public void ClearMemoryHisData(MarshalMemoryBlock memory)
{
Stopwatch sw = new Stopwatch();
sw.Start();
memory.Clear();
memory.WriteByteDirect(0, 0);
//foreach(var vv in mHisTags)
//{
// vv.Value.ClearDataValue(memory);
//}
sw.Stop();
LoggerService.Service.Info("Record", "清空数据区耗时:" + sw.ElapsedMilliseconds);
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
private MarshalMemoryBlock CompressBlockMemory(ManualHisDataMemoryBlock data)
{
MarshalMemoryBlock block = MarshalMemoryBlockPool.Pool.Get(data.Length * 2 + 28 + 5 + 56);
var histag = mHisTagService.GetHisTag(data.Id);
if (histag == null)
{
return(null);
}
int datasize = 0;
var targetPosition = 28 + 56;
//前56个字节用于统计数据存放
block.WriteInt(56, data.Id);
block.WriteDatetime(56 + 4, data.Time); //时间
block.WriteDatetime(56 + 12, data.EndTime); //结束时间
//block.WriteInt(20, 0); //写入数据大小
block.WriteInt(56 + 24, mTagIds.Count);//写入变量的个数
var qulityoffset = data.QualityAddress;
var comtype = histag.CompressType;//压缩类型
block.WriteByte(targetPosition + 4, (byte)comtype);
var tp = mCompressCach[comtype];
if (tp != null)
{
tp.QulityOffset = (int)qulityoffset;
tp.TagType = histag.TagType;
tp.RecordType = histag.Type;
tp.StartTime = data.Time;
tp.Parameters = histag.Parameters;
tp.Precision = histag.Precision;
tp.TimeTick = data.TimeUnit;
tp.Id = data.Id;
var size = tp.Compress(data, 0, block, targetPosition + 5, data.Length, block, 0) + 1;
block.WriteInt(targetPosition, (int)size);
datasize = (int)(targetPosition + size + 5);
block.WriteInt(56 + 20, datasize); //写入数据大小
}
return(block);
}
/// <summary>
///
/// </summary>
/// <param name="start"></param>
/// <param name="len"></param>
/// <returns></returns>
public override MarshalMemoryBlock Read(long start, int len)
{
var vtmp = len / 1024 * 100;
vtmp = len % (1024 * 100) > 0 ? vtmp + 1 : vtmp;
MarshalMemoryBlock re = new MarshalMemoryBlock(len, 1024 * 100);
mStream.Position = start;
byte[] bval = new byte[len];
mStream.Read(bval, 0, len);
re.WriteBytesDirect(0, bval);
//mStream.Write(re.StartMemory, 0, len);
return(re);
}
/// <summary>
///
/// </summary>
/// <param name="datafile"></param>
/// <param name="address"></param>
private unsafe MarshalMemoryBlock ReadAndDecompressMemory(DataFileSeriserbase datafile, long address)
{
var vsize = datafile.ReadInt(address);
var dsize = datafile.ReadInt(address + 4);
var datas = datafile.Read(address + 8, vsize);
int dtmp = 0;
MarshalMemoryBlock mmb = new MarshalMemoryBlock(dsize, dsize);
System.IO.Compression.BrotliDecoder.TryDecompress(new ReadOnlySpan <byte>((void *)datas.Handles[0], vsize), new Span <byte>((void *)mmb.Handles[0], dsize), out dtmp);
if (dtmp != dsize)
{
LoggerService.Service.Warn("DataFileInfo", "解压缩数据长度不一致!" + datafile.FileName);
}
datas.Dispose();
return(mmb);
}
/// <summary>
///
/// </summary>
/// <param name="source"></param>
/// <param name="offset"></param>
/// <param name="totalcount"></param>
/// <param name="usedIndex"></param>
/// <returns></returns>
protected new Memory <byte> CompressQulitys(MarshalMemoryBlock source, long offset, int totalcount, Queue <int> usedIndex)
{
int count = 1;
byte qus = source.ReadByte(offset);
//using (VarintCodeMemory memory = new VarintCodeMemory(qulitys.Length * 2))
mVarintMemory.Position = 0;
int ig = -1;
usedIndex.TryDequeue(out ig);
mVarintMemory.WriteInt32(qus);
for (int i = 1; i < totalcount; i++)
{
if (i == ig)
{
byte bval = source.ReadByte(offset + i);
if (bval == qus)
{
count++;
}
else
{
mVarintMemory.WriteInt32(count);
qus = bval;
mVarintMemory.WriteInt32(qus);
count = 1;
}
if (usedIndex.Count > 0)
{
usedIndex.TryDequeue(out ig);
}
}
}
mVarintMemory.WriteInt32(count);
return(mVarintMemory.Buffer.AsMemory(0, mVarintMemory.Position));
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="sourceAddr"></param>
/// <param name="target"></param>
/// <param name="targetAddr"></param>
/// <param name="size"></param>
/// <returns></returns>
protected override long Compress <T>(MarshalMemoryBlock source, long sourceAddr, MarshalMemoryBlock target, long targetAddr, long size)
{
var count = (int)(size - this.QulityOffset);
var tims = source.ReadUShorts(sourceAddr, (int)count);
if (mMarshalMemory == null)
{
mMarshalMemory = new MemoryBlock(count * 10);
}
if (mVarintMemory == null)
{
mVarintMemory = new VarintCodeMemory(count * 10);
}
Queue <int> emptys = GetEmpityTimers(tims);
Queue <int> usedIndex;
long rsize = 0;
if (typeof(T) == typeof(byte))
{
var cval = CompressValues <byte>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 3 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(cval.Length);
target.Write(cval);
rsize += 4;
rsize += cval.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
else if (typeof(T) == typeof(short))
{
var res = CompressValues <short>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 4 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(res.Length);
target.Write(res);
rsize += 4;
rsize += res.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
else if (typeof(T) == typeof(ushort))
{
var res = CompressValues <ushort>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 4 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(res.Length);
target.Write(res);
rsize += 4;
rsize += res.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
else if (typeof(T) == typeof(int))
{
var res = CompressValues <int>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 6 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(res.Length);
target.Write(res);
rsize += 4;
rsize += res.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
else if (typeof(T) == typeof(uint))
{
var res = CompressValues <uint>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 6 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(res.Length);
target.Write(res);
rsize += 4;
rsize += res.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
else if (typeof(T) == typeof(long))
{
var res = CompressValues <long>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 10 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(res.Length);
target.Write(res);
rsize += 4;
rsize += res.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
else if (typeof(T) == typeof(ulong))
{
var res = CompressValues <ulong>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 10 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(res.Length);
target.Write(res);
rsize += 4;
rsize += res.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
else if (typeof(T) == typeof(double))
{
var res = CompressValues <double>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 10 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(res.Length);
target.Write(res);
rsize += 4;
rsize += res.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
else if (typeof(T) == typeof(float))
{
var res = CompressValues <float>(source, count * 2 + sourceAddr, count, emptys, tims, out usedIndex);
target.WriteUShort(targetAddr, (ushort)usedIndex.Count);
rsize += 2;
var cqus = CompressQulitys(source, count * 6 + sourceAddr, count, new Queue <int>(usedIndex));
var timeData = CompressTimers(tims, usedIndex);
target.Write((int)timeData.Length);
target.Write(timeData);
rsize += 4;
rsize += timeData.Length;
target.Write(res.Length);
target.Write(res);
rsize += 4;
rsize += res.Length;
target.Write(cqus.Length);
target.Write(cqus);
rsize += 4;
rsize += cqus.Length;
}
return(rsize);
}
/// <summary>
///
/// </summary>
/// <param name="datafile"></param>
/// <param name="tid"></param>
/// <param name="offset"></param>
/// <param name="dataTimes"></param>
/// <param name="timetick"></param>
/// <returns></returns>
private static Dictionary <MarshalMemoryBlock, Tuple <List <DateTime>, int> > ReadTagDataBlock2(DataFileSeriserbase datafile, int tid, long offset, List <DateTime> dataTimes, out int timetick)
{
int fileDuration, blockDuration = 0;
int tagCount = 0;
long blockpointer = 0;
DateTime time;
//var tagIndex = ReadTagIndexInDataPointer(datafile,tid, offset, out tagCount, out fileDuration, out blockDuration, out timetick, out blockpointer, out time);
ReadRegionHead(datafile, offset, out tagCount, out fileDuration, out blockDuration, out timetick, out blockpointer, out time);
var tagIndex = tid % tagCount;
Dictionary <long, MarshalMemoryBlock> rtmp = new Dictionary <long, MarshalMemoryBlock>();
Dictionary <MarshalMemoryBlock, Tuple <List <DateTime>, int> > re = new Dictionary <MarshalMemoryBlock, Tuple <List <DateTime>, int> >();
if (tagCount == 0)
{
return(re);
}
int blockcount = fileDuration * 60 / blockDuration;
var startTime = datafile.ReadDateTime(0);
int buffersize = 1024 * 1024 * 2;
//分配读缓存
IntPtr mdataBuffer = Marshal.AllocHGlobal(buffersize);
long mbufferadderss = 0;
int bufferLen = buffersize;
// var headdata = GetHeadBlock(datafile, offset + blockpointer, tagCount * blockcount * 12);
var headdata = datafile.Read(offset + blockpointer + tagIndex * blockcount * 8, blockcount * 8);
long mLastBuffer = 0;
int mLastDataLoc = 0;
int mLastDataSize = 0;
MarshalMemoryBlock vmm = null;
foreach (var vdd in dataTimes)
{
var ttmp = (vdd - startTime).TotalMinutes;
int blockindex = (int)(ttmp / blockDuration);
if (blockindex > blockcount)
{
throw new Exception("DataPointer index is out of total block number");
}
//var dataPointer = headdata.ReadInt(tagIndex * blockcount * 12 + blockindex * 12); //读取DataBlock的相对地址
//var dataPointerbase = headdata.ReadLong(tagIndex * blockcount * 12 + blockindex * 12 + 4); //读取DataBlock的基地址
var dataPointer = headdata.ReadInt(blockindex * 8); //读取DataBlock的相对地址
//var dataPointerbase = headdata.ReadLong(blockindex * 12 + 4); //读取DataBlock的基地址
if (dataPointer > 0)
{
////var datasize = datafile.ReadInt(dataPointer); //读取DataBlock 的大小
//var vmm = GetDataMemory(datafile, dataPointerbase, dataPointer);
//说明数据没有采用Zip压缩，可以直接读取使用
var dp = dataPointer;
int datasize = 0;
int dataloc = 0;
if (dp >= mbufferadderss && (dp - mbufferadderss + 4) <= bufferLen && (dp - mbufferadderss + 4 + MemoryHelper.ReadInt32(mdataBuffer, dp - mbufferadderss)) <= bufferLen)
{
datasize = MemoryHelper.ReadInt32(mdataBuffer, dp - mbufferadderss);
dataloc = (int)(dp - mbufferadderss + 4);
}
else
{
bufferLen = datafile.Read(mdataBuffer, dp, buffersize);
mbufferadderss = dp;
datasize = MemoryHelper.ReadInt32(mdataBuffer, 0);
dataloc = (int)(dp - mbufferadderss + 4);
}
if (datasize > 0 && (mLastBuffer != mbufferadderss || mLastDataLoc != dataloc || mLastDataSize != datasize))
{
vmm = new MarshalMemoryBlock(datasize, datasize);
MemoryHelper.MemoryCopy(mdataBuffer, dataloc, vmm.Buffers[0], 0, datasize);
mLastBuffer = mbufferadderss;
mLastDataLoc = dataloc;
mLastDataSize = datasize;
}
else if (datasize <= 0)
{
vmm = null;
}
if (vmm != null)
{
if (!rtmp.ContainsKey(dataPointer))
{
//var rmm = datafile.Read(dataPointer + 4, datasize);
if (!re.ContainsKey(vmm))
{
re.Add(vmm, new Tuple <List <DateTime>, int>(new List <DateTime>()
{
vdd
}, blockindex));
}
else
{
re[vmm].Item1.Add(vdd);
}
rtmp.Add(dataPointer, vmm);
}
else
{
//var rmm = rtmp[dataPointer];
if (!re.ContainsKey(vmm))
{
re.Add(vmm, new Tuple <List <DateTime>, int>(new List <DateTime>()
{
vdd
}, blockindex));
}
else
{
re[vmm].Item1.Add(vdd);
}
}
}
}
}
headdata.Dispose();
Marshal.FreeHGlobal(mdataBuffer);
return(re);
}
/// <summary>
///
/// </summary>
public StatisticsMemoryMap()
{
mHead = new MarshalMemoryBlock(TagTotalCount * 8, TagTotalCount * 8);
mData = new MarshalMemoryBlock(TagTotalCount * 48 * 24 + 48, TagTotalCount * 48 * 24 + 48);
}
/// <summary> /// /// </summary> /// <param name="source"></param> /// <param name="sourceAddr"></param> /// <param name="tp"></param> /// <returns></returns> public abstract TagHisValue <T> DeCompressRawValue <T>(MarshalMemoryBlock source, int sourceAddr, byte tp);
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="sourceAddr"></param> /// <param name="time"></param> /// <param name="timeTick"></param> /// <param name="type"></param> /// <param name="result"></param> /// <returns></returns> public abstract int DeCompressValue <T>(MarshalMemoryBlock source, int sourceAddr, List <DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult <T> result, Func <byte, object> ReadOtherDatablockAction);
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="offset"></param>
/// <param name="count"></param>
/// <param name="emptyIds"></param>
/// <returns></returns>
protected override Memory <byte> CompressValues <T>(MarshalMemoryBlock source, long offset, int count, Queue <int> emptyIds)
{
var deadArea = this.Parameters.ContainsKey("DeadValue") ? this.Parameters["DeadValue"] : 0;
var deadType = (int)(this.Parameters.ContainsKey("DeadType") ? this.Parameters["DeadType"] : 0);
mMarshalMemory.Position = 0;
mVarintMemory.Position = 0;
bool isFirst = true;
int ig = -1;
emptyIds.TryDequeue(out ig);
if (typeof(T) == typeof(byte))
{
byte sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadByte(offset + i);
if (isFirst)
{
sval = id;
mMarshalMemory.Write(id);
isFirst = false;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mMarshalMemory.Write(id);
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(mMarshalMemory.StartMemory.AsMemory <byte>(0, (int)mMarshalMemory.Position));
}
else if (typeof(T) == typeof(short))
{
short sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadShort(offset + i * 2);
if (isFirst)
{
mVarintMemory.WriteSInt32(id);
isFirst = false;
sval = id;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mVarintMemory.WriteSInt32(id - sval);
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
}
else if (typeof(T) == typeof(ushort))
{
ushort sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadUShort(offset + i * 2);
if (isFirst)
{
mVarintMemory.WriteSInt32(id);
isFirst = false;
sval = id;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mVarintMemory.WriteSInt32(id - sval);
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
}
else if (typeof(T) == typeof(int))
{
int sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadInt(offset + i * 4);
if (isFirst)
{
mVarintMemory.WriteInt32(id);
isFirst = false;
sval = id;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mVarintMemory.WriteSInt32(id - sval);
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
}
else if (typeof(T) == typeof(uint))
{
uint sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadUInt(offset + i * 4);
if (isFirst)
{
mVarintMemory.WriteInt32(id);
isFirst = false;
sval = id;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mVarintMemory.WriteSInt32((int)(id - sval));
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
}
else if (typeof(T) == typeof(long))
{
long sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadLong(offset + i * 8);
if (isFirst)
{
mVarintMemory.WriteInt64(id);
isFirst = false;
sval = id;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mVarintMemory.WriteSInt64((id - sval));
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
}
else if (typeof(T) == typeof(ulong))
{
ulong sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadULong(offset + i * 8);
if (isFirst)
{
mVarintMemory.WriteInt64(id);
isFirst = false;
sval = id;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mVarintMemory.WriteSInt64((long)(id - sval));
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
}
else if (typeof(T) == typeof(double))
{
double sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadDouble(offset + i * 8);
if (isFirst)
{
mMarshalMemory.Write(id);
isFirst = false;
sval = id;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mMarshalMemory.Write(id);
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(mMarshalMemory.StartMemory.AsMemory <byte>(0, (int)mMarshalMemory.Position));
}
else if (typeof(T) == typeof(float))
{
float sval = 0;
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadFloat(offset + i * 4);
if (isFirst)
{
mMarshalMemory.Write(id);
isFirst = false;
sval = id;
}
else
{
if (CheckIsNeedRecord(sval, id, deadArea, deadType))
{
mMarshalMemory.Write(id);
sval = id;
}
}
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(mMarshalMemory.StartMemory.AsMemory <byte>(0, (int)mMarshalMemory.Position));
}
return(mVarintMemory.Buffer.AsMemory <byte>(0, (int)mVarintMemory.Position));
}
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="sourceAddr"></param> /// <param name="time"></param> /// <param name="timeTick"></param> /// <param name="type"></param> /// <param name="result"></param> /// <returns></returns> public abstract int DeCompressValue <T>(MarshalMemoryBlock source, int sourceAddr, List <DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult <T> result);
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="sourceAddr"></param> /// <param name="time"></param> /// <param name="timeTick"></param> /// <param name="type"></param> /// <returns></returns> public abstract object DeCompressValue <T>(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
/// <summary> /// /// </summary> /// <param name="source"></param> /// <param name="sourceAddr"></param> /// <param name="target"></param> /// <param name="targetAddr"></param> /// <param name="size"></param> /// <returns></returns> public abstract long Compress(MarshalMemoryBlock source, long sourceAddr, MarshalMemoryBlock target, long targetAddr, long size);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <param name="timeTick"></param>
///// <returns></returns>
//public abstract bool? DeCompressBoolValue(MarshalMemoryBlock source, int sourceAddr,DateTime time,int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressBoolValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<bool> result);
///// <summary>
///// 解压缩某个事件段内所有值
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime,DateTime endTime, int timeTick, HisQueryResult<bool> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract byte? DeCompressByteValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressByteValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<byte> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<byte> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract short? DeCompressShortValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressShortValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<short> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<short> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract ushort? DeCompressUShortValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressUShortValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<ushort> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<ushort> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int? DeCompressIntValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressIntValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<int> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<int> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract uint? DeCompressUIntValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressUIntValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<uint> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<uint> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract long? DeCompressLongValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressLongValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<long> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<long> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract ulong? DeCompressULongValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressULongValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<ulong> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<ulong> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <param name="timeTick"></param>
///// <returns></returns>
//public abstract float? DeCompressFloatValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <param name="timeTick"></param>
///// <returns></returns>
//public abstract int DeCompressFloatValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<float> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<float> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <param name="timeTick"></param>
///// <returns></returns>
//public abstract double? DeCompressDoubleValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <param name="timeTick"></param>
///// <returns></returns>
//public abstract int DeCompressDoubleValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<double> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<double> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract DateTime? DeCompressDateTimeValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressDateTimeValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<DateTime> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<DateTime> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract string DeCompressStringValue(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="time"></param>
///// <returns></returns>
//public abstract int DeCompressStringValue(MarshalMemoryBlock source, int sourceAddr, List<DateTime> time, int timeTick, QueryValueMatchType type, HisQueryResult<string> result);
///// <summary>
/////
///// </summary>
///// <param name="source"></param>
///// <param name="sourceAddr"></param>
///// <param name="startTime"></param>
///// <param name="endTime"></param>
///// <param name="timeTick"></param>
///// <param name="result"></param>
///// <returns></returns>
//public abstract int DeCompressAllValue(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult<string> result);
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="sourceAddr"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="timeTick"></param>
/// <param name="result"></param>
/// <returns></returns>
public abstract int DeCompressAllValue <T>(MarshalMemoryBlock source, int sourceAddr, DateTime startTime, DateTime endTime, int timeTick, HisQueryResult <T> result);
/// <summary>
///
/// </summary>
/// <param name="datafile"></param>
/// <param name="startTime"></param>
/// <param name="tid"></param>
/// <param name="offset"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="timetick"></param>
/// <returns></returns>
private static IEnumerable <Tuple <MarshalMemoryBlock, DateTime, DateTime, int> > ReadTagDataBlock2(DataFileSeriserbase datafile, int tid, long offset, DateTime start, DateTime end)
{
int fileDuration, blockDuration = 0;
int tagCount = 0;
long blockpointer = 0;
int timetick = 0;
DateTime time;
//var tagIndex = ReadTagIndexInDataPointer(datafile,tid, offset, out tagCount, out fileDuration, out blockDuration, out timetick, out blockpointer, out time);
ReadRegionHead(datafile, offset, out tagCount, out fileDuration, out blockDuration, out timetick, out blockpointer, out time);
var tagIndex = tid % tagCount;
int blockcount = fileDuration * 60 / blockDuration;
//读取文件开始时间
var startTime = datafile.ReadDateTime(0);
DateTime sstart = start;
DateTime send = end;
int buffersize = 1024 * 1024 * 2;
//分配读缓存
IntPtr mdataBuffer = Marshal.AllocHGlobal(buffersize);
long mbufferadderss = 0;
int bufferLen = 0;
//var headdata = GetHeadBlock(datafile, offset + blockpointer, tagCount * blockcount * 12);
var headdata = datafile.Read(offset + blockpointer + tagIndex * blockcount * 8, blockcount * 8);
while (sstart < end)
{
var ttmp = Math.Round((sstart - startTime).TotalSeconds, 3);
var vv = blockDuration * 60 - (ttmp % (blockDuration * 60));
send = sstart.AddSeconds(vv);
if (send > end)
{
send = end;
}
int blockindex = (int)(ttmp / (blockDuration * 60));
if (blockindex >= blockcount)
{
break;
//throw new Exception("DataPointer index is out of total block number");
}
var dataPointer = headdata.ReadInt(blockindex * 8); //读取DataBlock的相对地址
if (dataPointer > 0)
{
MarshalMemoryBlock vmm = null;
//说明数据没有采用Zip压缩，可以直接读取使用
var dp = dataPointer;
int datasize = 0;
int dataloc = 0;
if (dp >= mbufferadderss && (dp - mbufferadderss + 4) <= bufferLen && (dp - mbufferadderss + 4 + MemoryHelper.ReadInt32(mdataBuffer, dp - mbufferadderss)) <= bufferLen)
{
datasize = MemoryHelper.ReadInt32(mdataBuffer, dp - mbufferadderss);
dataloc = (int)(dp - mbufferadderss + 4);
}
else
{
bufferLen = datafile.Read(mdataBuffer, dp, buffersize);
mbufferadderss = dp;
datasize = MemoryHelper.ReadInt32(mdataBuffer, 0);
dataloc = (int)(dp - mbufferadderss + 4);
}
if (datasize > 0 && datasize < datafile.Length)
{
vmm = new MarshalMemoryBlock(datasize, datasize);
MemoryHelper.MemoryCopy(mdataBuffer, dataloc, vmm.Buffers[0], 0, datasize);
}
if (vmm != null)
{
yield return(new Tuple <MarshalMemoryBlock, DateTime, DateTime, int>(vmm, sstart, send, timetick));
}
}
sstart = send;
}
headdata.Dispose();
Marshal.FreeHGlobal(mdataBuffer);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="offset"></param>
/// <param name="count"></param>
/// <param name="emptyIds"></param>
/// <param name="mTimers"></param>
/// <param name="usedTimerIndex"></param>
/// <returns></returns>
protected Memory <byte> CompressValues <T>(MarshalMemoryBlock source, long offset, int count, Queue <int> emptyIds, List <ushort> mTimers, out Queue <int> usedTimerIndex)
{
int ig = -1;
emptyIds.TryDequeue(out ig);
if (typeof(T) == typeof(byte))
{
Dictionary <ushort, byte> mavaibleValues = new Dictionary <ushort, byte>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadByte(offset + i);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
else if (typeof(T) == typeof(short))
{
Dictionary <ushort, short> mavaibleValues = new Dictionary <ushort, short>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadShort(offset + i);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
else if (typeof(T) == typeof(ushort))
{
Dictionary <ushort, ushort> mavaibleValues = new Dictionary <ushort, ushort>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadUShort(offset + i);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
else if (typeof(T) == typeof(int))
{
Dictionary <ushort, int> mavaibleValues = new Dictionary <ushort, int>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadInt(offset + i);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
else if (typeof(T) == typeof(uint))
{
Dictionary <ushort, uint> mavaibleValues = new Dictionary <ushort, uint>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadUInt(offset + i);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
else if (typeof(T) == typeof(long))
{
Dictionary <ushort, long> mavaibleValues = new Dictionary <ushort, long>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadLong(offset + i * 8);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
else if (typeof(T) == typeof(ulong))
{
Dictionary <ushort, ulong> mavaibleValues = new Dictionary <ushort, ulong>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadULong(offset + i * 8);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
else if (typeof(T) == typeof(double))
{
Dictionary <ushort, double> mavaibleValues = new Dictionary <ushort, double>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadDouble(offset + i * 8);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
else if (typeof(T) == typeof(float))
{
Dictionary <ushort, float> mavaibleValues = new Dictionary <ushort, float>();
for (int i = 0; i < count; i++)
{
if (i != ig)
{
var id = source.ReadFloat(offset + i * 4);
mavaibleValues.Add(mTimers[i], id);
}
else
{
if (emptyIds.Count > 0)
{
emptyIds.TryDequeue(out ig);
}
}
}
return(SlopeCompress(mavaibleValues, out usedTimerIndex));
}
usedTimerIndex = null;
return(null);
}
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="sourceAddr"></param> /// <param name="time"></param> /// <param name="timeTick"></param> /// <param name="type"></param> /// <returns></returns> public abstract object DeCompressValue <T>(MarshalMemoryBlock source, int sourceAddr, DateTime time, int timeTick, QueryValueMatchType type, Func <byte, object> ReadOtherDatablockAction);
/// <summary>
/// 执行存储到磁盘
/// </summary>
public void SaveToFile(MarshalMemoryBlock mProcessMemory, long dataOffset, DateTime time)
{
/*
* 1. 检查变量ID是否变动，如果变动则重新记录变量的ID列表
* 2. 拷贝数据块
* 3. 更新数据块指针
*/
//LoggerService.Service.Info("SeriseFileItem" + Id, "*********开始执行存储**********");
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
var totalsize = mProcessMemory.ReadInt(dataOffset);
var count = mProcessMemory.ReadInt(dataOffset + 4);
mTagCount = count;
mCurrentTime = time;
//to do 计算变量信息是否改变
////判断变量的ID列表是否被修改了
//for (int i = 0; i < count; i++)
//{
// var id = mProcessMemory.ReadInt(offset);
// if (!mIdAddrs.ContainsKey(id))
// {
// mNeedUpdateTagHeads = true;
// break;
// }
// offset += 8;
//}
var ltmp = sw.ElapsedMilliseconds;
if (!CheckFile(time))
{
return;
}
var ltmp2 = sw.ElapsedMilliseconds;
long offset = 8 + dataOffset;
long start = count * 8 + offset;//计算出数据起始地址
//LoggerService.Service.Info("SeriseFileItem" + Id, "开始更新指针区域");
var dataAddr = this.mFileWriter.GoToEnd().CurrentPostion;
mBlockPointMemory.CheckAndResize(mTagCount * 8);
mBlockPointMemory.Clear();
//更新BlockPoint
for (int i = 0; i < count; i++)
{
var id = mProcessMemory.ReadInt(offset);
var addr = mProcessMemory.ReadInt(offset + 4) - start + dataAddr;
offset += 8;
if (id > -1)
{
mBlockPointMemory.WriteLong(i * 8, addr);
}
}
//StringBuilder sb = new StringBuilder();
//foreach (var vv in mBlockPointMemory.ToLongList())
//{
// sb.Append(vv + ",");
//}
//计算本次更新对应的指针区域的起始地址
FileStartHour = (time.Hour / FileDuration) * FileDuration;
int bid = ((time.Hour - FileStartHour) * 60 + time.Minute) / BlockDuration;
var pointAddr = mBlockPointOffset + count * 8 * bid;
var ltmp3 = sw.ElapsedMilliseconds;
//lock (mFileLocker)
{
mFileWriter.GoToEnd();
long lpp = mFileWriter.CurrentPostion;
mProcessMemory.WriteToStream(mFileWriter.GetStream(), start, totalsize - start);//直接拷贝数据块
// LoggerService.Service.Info("SeriseFileItem", "数据写入地址:" + lpp + ",更新指针地址：" + pointAddr+" block index:"+bid+" tagcount:"+count+" block point Start Addr:"+ mBlockPointOffset+" point values:"+sb.ToString());
//this.mFileWriter.Append(mProcessMemory.Buffers, (int)start, (int)(totalsize - start));
mFileWriter.Write(mBlockPointMemory.Buffers, pointAddr, 0, (int)mBlockPointMemory.AllocSize);
Flush();
}
sw.Stop();
LoggerService.Service.Info("SeriseFileItem" + Id, "写入数据 " + mCurrentFileName + " 数据大小：" + ((totalsize - start) + mBlockPointMemory.AllocSize) / 1024.0 / 1024 + " m" + "其他脚本耗时:" + ltmp + "," + (ltmp2 - ltmp) + "," + (ltmp3 - ltmp2) + "存储耗时:" + (sw.ElapsedMilliseconds - ltmp3));
}
catch (System.IO.IOException ex)
{
LoggerService.Service.Erro("SeriseEnginer" + Id, ex.Message);
}
//LoggerService.Service.Info("SeriseEnginer" + Id, ">>>>>>>>>完成执行存储>>>>>>>>>");
}
/// <summary>
///
/// </summary>
/// <param name="mProcessMemory"></param>
/// <param name="time"></param>
public void SaveToFile(MarshalMemoryBlock mProcessMemory, DateTime time)
{
SaveToFile(mProcessMemory, 0, time);
}
