private static int BinOneGenomicInterval(CanvasBinParameters parameters,
Dictionary <string, BitArray> possibleAlignments,
Dictionary <string, HitArray> observedAlignments,
Dictionary <string, Int16[]> fragmentLengths)
{
InitializeAlignmentArrays(parameters.referenceFile, parameters.chromosome, parameters.coverageMode, possibleAlignments, observedAlignments, fragmentLengths);
Console.WriteLine("{0} Initialized alignment arrays", DateTime.Now);
LoadObservedAlignmentsBAM(parameters.bamFile, parameters.isPairedEnd, parameters.chromosome, parameters.coverageMode, observedAlignments[parameters.chromosome], fragmentLengths[parameters.chromosome]);
Console.WriteLine("{0} Loaded observed alignments", DateTime.Now);
// Filter on BED file.
if (parameters.filterFile != null)
{
ExcludeTagsOverlappingFilterFile(parameters.filterFile, possibleAlignments);
}
// Make sure we don't have an 'impossible' observed alignment.
ScreenObservedTags(observedAlignments, possibleAlignments);
Console.WriteLine("{0} Serialize intermediate data", DateTime.Now);
//output binary intermediate file
IntermediateData data = new IntermediateData(possibleAlignments, observedAlignments, fragmentLengths, parameters.coverageMode);
Directory.CreateDirectory(Path.GetDirectoryName(parameters.outFile));
using (FileStream stream = new FileStream(parameters.outFile, FileMode.Create, FileAccess.Write))
{
ProtoBuf.Serializer.Serialize <IntermediateData>(stream, data);
}
Console.WriteLine("{0} Intermediate data serialized", DateTime.Now);
return(0);
}
public async Task MakeTest()
{
// translate source files
var tx = new CSharp2CPPTranslator();
var source = new FSSnapshot();
source.Files.Add(LoadSource("SOCBlinker.cs"));
tx.Run(source);
var firmwareSource = tx.Result;
// create soc resource records
var socGenerator = new SOCGenerator();
var socRecordsBuilder = new SOCRecordsBuilder();
var socRecords = socRecordsBuilder.ToSOCRecords(0x800, tx.SOCResources);
firmwareSource.Add(socGenerator.SOCImport(socRecords));
IntermediateData.SaveToMake(firmwareSource);
// run makefile
var context = RISCVIntegration
.DefaultContext(TestPath.MakeFolder)
.WithMakeTarget("bin");
await RISCVIntegrationClient.Make(context);
}
public VoxelModelGenerateTask(IVoxelVolume volume, IVoxelMaterialResolver resolver, VoxelModelGenerationSettings settings)
{
m_Volume = volume;
m_MaterialResolver = resolver;
m_Settings = settings;
m_Intermediate = new IntermediateData();
}
void SetLatestListData(IntermediateData data)
{
int column = (int)LatestDataGridView_Columns.Value;
foreach (var item in data.Values)
{
var dataId = item.Key;
latestDataGridView[column, (int)dataId].Value = item.Value;
}
}
/// <summary>
/// SmoothIntermediateDataをIntermediateDataHistoryから作成
/// ※最新データから作成
/// </summary>
void UpdateSmooth()
{
const int Count = 10;
var totalIntermediateData = new IntermediateData(0);
foreach (var dataId in DataIds)
{
totalIntermediateData.Values[dataId] = 0;
}
foreach (var item in IntermediateDataHistory.Reverse().Take(Count))
{
foreach (var dataId in DataIds)
{
totalIntermediateData.Values[dataId] += item.Value.Values[dataId];
}
}
foreach (var dataId in DataIds)
{
SmoothIntermediateData.Values[dataId] = totalIntermediateData.Values[dataId] / Count;
}
}
/// <summary>
/// Deserialize CanvasBin object in multiple threads
/// </summary>
/// <param name="inputFile">inputFile with per-chromosome CanvasBin objects.</param>
/// <param name="possibleAlignments">Stores which alignments are possible (perfect and unique).</param>
/// <param name="observedAlignments">Stores observed alignments from a sample.</param>
/// <param name="fragmentLengths">Stores fragment length in byte format.</param>
public static void DeserializeCanvasData(string inputFile, Dictionary <string, BitArray> possibleAlignments,
Dictionary <string, HitArray> observedAlignments, Dictionary <string, Int16[]> fragmentLengths,
Object semaphore, CanvasCoverageMode coverageMode)
{
IntermediateData data = null;
using (FileStream stream = new FileStream(inputFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
Stopwatch watch = new Stopwatch();
watch.Start();
data = ProtoBuf.Serializer.Deserialize <IntermediateData>(stream);
watch.Stop();
Console.WriteLine("File: {0}", inputFile);
Console.WriteLine("Time elapsed: {0}", watch.Elapsed);
}
Dictionary <string, BitArray> tempPossibleAlignments;
Dictionary <string, HitArray> tempObservedAlignments;
Dictionary <string, Int16[]> tempFragmentLengths;
data.GetData(out tempPossibleAlignments, out tempObservedAlignments, out tempFragmentLengths);
lock (semaphore)
{
foreach (KeyValuePair <string, BitArray> kvp in tempPossibleAlignments)
{
possibleAlignments.Add(kvp.Key, kvp.Value);
}
foreach (KeyValuePair <string, HitArray> kvp in tempObservedAlignments)
{
observedAlignments.Add(kvp.Key, kvp.Value);
}
if (coverageMode == CanvasCoverageMode.GCContentWeighted)
{
foreach (KeyValuePair <string, Int16[]> kvp in tempFragmentLengths)
{
fragmentLengths.Add(kvp.Key, kvp.Value);
}
}
}
}
/// <summary>
/// LatestDataLongGetの処理の
/// </summary>
private void LatestDataLongGet_FromIpcServer()
{
// 受信データの一時保管
var receivedData = new Dictionary <long, byte[]>();
// TODO:System.Runtime.Remoting.RemotingException対応
try
{
var remoteObject = IpcClient.GetRemoteObject();
// サーバー等のRemoteObjectの更新を待つ
IpcClient.Mutex.WaitOne();
Console.WriteLine($"{nameof(remoteObject.TimeStamp)}={remoteObject.TimeStamp.ToString()}");
Console.WriteLine($"{nameof(remoteObject.UpdateCompleted)}={remoteObject.UpdateCompleted}");
#if DEBUG
// わざと遅延させてデータ更新中にアクセスしていないかチェックしやすくする
Thread.Sleep(100);
#endif
if (remoteObject.UpdateCompleted == false)
{
throw new Exception($"排他制御が正常にできていない {nameof(remoteObject.UpdateCompleted)}==false");
}
// 前回の取得日時より後なら取得
if (lastTimeStampTicks < remoteObject.TimeStampTicks &&
remoteObject.UpdateCompleted)
{
foreach (var key in remoteObject.ReceivedDataHistory.Keys)
{
var data = remoteObject.GetReceivedData(key);
receivedData.Add(key, data);
}
}
}
catch (Exception ex)
{
measurementCheckBox.Checked = false;// 継続取得を中断
MessageBox.Show(ex.ToString(), ex.Message, MessageBoxButtons.OK);
}
finally
{
IpcClient.Mutex.ReleaseMutex();
}
// UIに反映
{
// 今回追加されたデータ
var intermediateDataHistory = new Dictionary <DateTime, IntermediateData>();
// 最後の取得時刻から最新時刻までを、中間データに追加
// 念の為、時刻でソートもする
foreach (var item in receivedData
.Where(item => item.Key > lastTimeStampTicks)
.OrderBy(item => item.Key))
{
// item.Keyは、UTCなので、表示用にLocalTimeに変換
var timeStamp = new DateTime(item.Key, DateTimeKind.Utc).ToLocalTime();
#if DEBUG
//Console.WriteLine($"{nameof(timeStamp)}={timeStamp}");
#endif
var frame = new Frame(item.Value);
var payload = frame.Payload;
if (payload is LatestDataLongResponsePayload)
{
var intermediateData = new IntermediateData(payload as LatestDataLongResponsePayload);
intermediateDataHistory.Add(timeStamp, intermediateData);
IntermediateDataHistory.Add(timeStamp, intermediateData);
}
}
// 関連データ更新
UpdateSmooth();
// 表は最新時刻のみ表示
if (IntermediateDataHistory.Keys.Count > 0)
{
var latestTimeStamp = IntermediateDataHistory.Keys.Max();
SetLatestListData(IntermediateDataHistory[latestTimeStamp]);
// lastTimeStampTicksはUTCなので変換
lastTimeStampTicks = latestTimeStamp.ToUniversalTime().Ticks;
}
// グラフに反映
AddChartData(intermediateDataHistory);
}
}
async Task TranslateSourceFiles(
IEnumerable <FSTextFile> files,
Action entryPoint
)
{
var textReplacer = new TextReplacer();
var generator = new IntegrationGenerator();
var firmwareTemplates = IntegrationTemplatesLoader.FirmwareTemplates;
var hardwareTemplates = IntegrationTemplatesLoader.HardwareTemplates;
var tx = new CSharp2CPPTranslator();
var source = new FSSnapshot();
source.Files.AddRange(files);
tx.Run(source);
var firmwareSource = tx.Result;
var socGenerator = new SOCGenerator();
var socRecords = new List <SOCRecord>();
var socRecordsBuilder = new SOCRecordsBuilder();
// default code block
socRecords.Add(new SOCRecord()
{
DataType = typeof(uint),
SegmentBits = 12,
HardwareName = "firmware",
SoftwareName = "firmware",
Segment = 0,
Depth = 512,
Template = "memory32"
});
socRecords.AddRange(socRecordsBuilder.ToSOCRecords(0x800, tx.SOCResources));
firmwareSource.Add(socGenerator.SOCImport(socRecords));
var generatedSourceFiles = firmwareSource.Files.Where(f => Path.GetExtension(f.Name).ToLower() == ".cpp").ToList();
var generatedHeaderFiles = firmwareSource.Files.Where(f => Path.GetExtension(f.Name).ToLower() == ".h").ToList();
firmwareSource.Merge(firmwareTemplates, f => !f.Name.Contains("template"));
var firmwareTemplate = firmwareTemplates.Get <FSTextFile>("firmware.template.cpp");
var firmwareMap = new Dictionary <string, string>()
{
{ "FIRMWARE_INCLUDES", string.Join(Environment.NewLine, generatedHeaderFiles.Select(f => $"#include \"{f.Name}\"")) },
{ "FIRMWARE_CODE", $"{entryPoint.Method.DeclaringType.Namespace}::{entryPoint.Method.DeclaringType.Name}::{entryPoint.Method.Name}();" },
};
firmwareSource.Add("firmware.cpp", textReplacer.ReplaceToken(firmwareTemplate.Content, firmwareMap));
var makefileTemplate = firmwareTemplates.Get <FSTextFile>("Makefile.template");
var makefileMap = new Dictionary <string, string>()
{
{ "SOURCES_LIST", string.Join(" ", generatedSourceFiles.Select(f => f.Name)) }
};
firmwareSource.Add("Makefile", textReplacer.ReplaceToken(makefileTemplate.Content, makefileMap));
IntermediateData.SaveFirmwareSource(firmwareSource);
var firmwareOutput = await CompileFromIntermediate();
IntermediateData.SaveFirmwareOutput(firmwareOutput);
// generat verilog
var hardwareTemplate = hardwareTemplates.Get <FSTextFile>("hardware.template.v").Content;
var replacers = new Dictionary <string, string>();
// memory init file
replacers["MEM_INIT"] = "";
foreach (var dma in socRecords)
{
var binFile = firmwareOutput.Get <FSBinaryFile>($"{dma.HardwareName}.bin");
if (binFile != null)
{
var words = TestTools.ReadWords(binFile.Content).ToList();
var memInit = generator.MemInit(words, dma.HardwareName, (int)dma.Depth, SizeOfType(dma.DataType));
replacers["MEM_INIT"] += memInit;
}
else
{
var memInit = generator.MemInit(Enumerable.Range(0, (int)dma.Depth).Select(idx => 0UL).ToList(), dma.HardwareName, (int)dma.Depth, SizeOfType(dma.DataType));
replacers["MEM_INIT"] += memInit;
}
}
// data declarations
replacers["DATA_DECL"] = generator.DataDeclaration(socRecords);
// data control signals
var templates = new IntegrationTemplates();
foreach (var t in hardwareTemplates.Files.OfType <FSTextFile>())
{
templates.Templates[t.Name] = t.Content;
}
replacers["DATA_CTRL"] = generator.DataControl(socRecords, templates);
replacers["MEM_READY"] = generator.MemReady(socRecords);
replacers["MEM_RDATA"] = generator.MemRData(socRecords);
hardwareTemplate = textReplacer.ReplaceToken(hardwareTemplate, replacers);
var hardwareSource = new FSSnapshot();
hardwareSource.Add("hardware.v", hardwareTemplate);
IntermediateData.SaveHardwareSource(hardwareSource);
}
public async Task CompileFromIntermediateTest()
{
var firmwareSnapshot = await CompileFromIntermediate();
IntermediateData.SaveFirmwareOutput(firmwareSnapshot);
}
private static int BinOneGenomicInterval(CanvasBinParameters parameters,
Dictionary<string, BitArray> possibleAlignments,
Dictionary<string, HitArray> observedAlignments,
Dictionary<string, Int16[]> fragmentLengths)
{
InitializeAlignmentArrays(parameters.referenceFile, parameters.chromosome, parameters.coverageMode, possibleAlignments, observedAlignments, fragmentLengths);
Console.WriteLine("{0} Initialized alignment arrays", DateTime.Now);
LoadObservedAlignmentsBAM(parameters.bamFile, parameters.isPairedEnd, parameters.chromosome, parameters.coverageMode, observedAlignments[parameters.chromosome], fragmentLengths[parameters.chromosome]);
Console.WriteLine("{0} Loaded observed alignments", DateTime.Now);
// Filter on BED file.
if (parameters.filterFile != null)
ExcludeTagsOverlappingFilterFile(parameters.filterFile, possibleAlignments);
// Make sure we don't have an 'impossible' observed alignment.
ScreenObservedTags(observedAlignments, possibleAlignments);
Console.WriteLine("{0} Serialize intermediate data", DateTime.Now);
//output binary intermediate file
IntermediateData data = new IntermediateData(possibleAlignments, observedAlignments, fragmentLengths, parameters.coverageMode);
Directory.CreateDirectory(Path.GetDirectoryName(parameters.outFile));
using (FileStream stream = new FileStream(parameters.outFile, FileMode.Create, FileAccess.Write))
{
ProtoBuf.Serializer.Serialize<IntermediateData>(stream, data);
}
Console.WriteLine("{0} Intermediate data serialized", DateTime.Now);
return 0;
}
private static IList<int> LatticeMultiply(IList<int> XData, IList<int> YData)
{
int XDataLen = XData.Count;
int YDataLen = YData.Count;
IntermediateData[,] lattice = new IntermediateData[XDataLen, YDataLen];
// Do multiplication on the lattice
for (int x = 0; x < XDataLen; x++)
{
for (int y = 0; y < YDataLen; y++)
{
int result = XData[x] * YData[y];
IntermediateData data;
data.TensPlace = result / 10;
data.OnesPlace = result % 10;
lattice[x, y] = data;
}
}
int pivot = XDataLen + 1;
int resultDigits = XDataLen + YDataLen + 1;
int[] resultComputation = new int[resultDigits];
for (int digit = resultDigits - 1, xIndex = XDataLen - 1, yIndex = YDataLen - 1; digit > 0; digit--)
{
// bottom right
if (digit >= pivot)
{
for (int xi = xIndex, yi = yIndex; xi >= 0 && yi < YDataLen; xi--, yi++)
{
resultComputation[digit] += lattice[xi, yi].OnesPlace;
if (yi + 1 < YDataLen)
{
resultComputation[digit] += lattice[xi, yi + 1].TensPlace;
}
}
resultComputation[digit - 1] = resultComputation[digit] / 10;
resultComputation[digit] = resultComputation[digit] % 10;
yIndex--;
}
// top left
else
{
for (int xi = xIndex, yi = yIndex; xi >= 0 && yi < YDataLen; xi--, yi++)
{
resultComputation[digit] += lattice[xi, yi].TensPlace;
if (xi - 1 >= 0)
{
resultComputation[digit] += lattice[xi - 1, yi].OnesPlace;
}
}
resultComputation[digit - 1] = resultComputation[digit] / 10;
resultComputation[digit] = resultComputation[digit] % 10;
xIndex--;
}
if (digit == pivot)
{
// When we reach pivot x decreases, reset the xIndex and yIndex
xIndex = XDataLen - 1;
yIndex = 0;
}
}
// trim the result of 0s
return resultComputation.SkipWhile(element => element == 0).ToList();
}
