Esempio n. 1
0
        public async Task Serialization()
        {
            var st        = new StringTable();
            var string1   = "asdf";
            var string2   = "jkl";
            var stringId1 = st.AddString(string1);
            var stringId2 = st.AddString(string2);

            using (MemoryStream ms = new MemoryStream())
            {
                using (BuildXLWriter writer = new BuildXLWriter(true, ms, true, logStats: true))
                {
                    st.Serialize(writer);
                }

                XAssert.IsTrue(ms.Position < StringTable.BytesPerBuffer,
                               "Small StringTable should not serialize a full empty byte buffer.");
                ms.Position = 0;

                using (BuildXLReader reader = new BuildXLReader(true, ms, true))
                {
                    st = await StringTable.DeserializeAsync(reader);
                }
            }

            XAssert.AreEqual(string1, st.GetString(stringId1));
            XAssert.AreEqual(string2, st.GetString(stringId2));

            XAssert.AreEqual(stringId1, st.AddString(string1));
            XAssert.AreEqual(stringId2, st.AddString(string2));
        }
Esempio n. 2
0
        public bool Deserialize(string path)
        {
            Console.WriteLine("Deserializing data...");
            using (var fs = new ProgressStream(File.Open(path, FileMode.Open), "DeserializedData"))
                using (var reader = new BuildXLReader(false, fs, false))
                {
                    Guid readVersion = reader.ReadGuid();
                    if (readVersion != VersionGuid)
                    {
                        return(false);
                    }

                    DataflowGraph = DeserializedDirectedGraph.DeserializeAsync(reader).Result;
                    var maxNode = (uint)DataflowGraph.NodeCount;
                    //reader.Read(maxNode, AggregateCosts, r => r.ReadUInt64());
                    reader.Read(maxNode, PipIds, r => r.ReadInt32());
                    reader.Read(maxNode, SemiStableHashes, r => r.ReadUInt64());
                    reader.Read(maxNode, StartTimes, r => r.ReadUInt64());
                    reader.Read(maxNode, Durations, r => r.ReadUInt64());
                    reader.Read(maxNode, PipTypes, r => (PipType)r.ReadByte());
                    //reader.Read(maxNode, CriticalChain, ReadNode);
                    MinStartTime  = reader.ReadUInt64();
                    MaxEndTime    = reader.ReadUInt64();
                    TotalDuration = reader.ReadUInt64();
                    //MaxAggregateCost = reader.ReadUInt64();
                    //CriticalPathHeadNode = ReadNode(reader);
                    //reader.Read(CriticalPath, ReadNode);
                    var stringTable = StringTable.DeserializeAsync(reader).Result;
                    SymbolTable = SymbolTable.DeserializeAsync(reader, Task.FromResult(stringTable)).Result;
                    reader.Read(maxNode, OutputValues, r => r.ReadFullSymbol());
                }

            Console.WriteLine("End deserializing data");
            Compute();
            return(true);
        }