protected override void Build(BufferAllocator allocator, ConnectedLayerGroups connectedLayerGroups, NNInitParameters initPars) { var oclInitPars = (OpenCLNNInitParameters)initPars; CreateOpenCLContext(oclInitPars); inputBuffer = connectedLayerGroups.InputBuffer; outputBuffer = connectedLayerGroups.OutputBuffer; }
public void TestDispose() { const int sliverSize = 4; // 4 floats = 16 bytes const int floatNumSlices = 11; // 11 slices per buffer, to test various cases BufferAllocator<float> bufferAllocator = new BufferAllocator<float>(sliverSize * floatNumSlices, 1, sizeof(float)); float continuousDuration = 2.4f; int discreteDuration = (int)Math.Round(continuousDuration + 1); float[] tempBuffer = AllocateSmall4FloatArray(discreteDuration, sliverSize); // check that allocated, then freed, buffers are used first for next allocation Buf<float> buffer = bufferAllocator.Allocate(); bufferAllocator.Free(buffer); Buf<float> buffer2 = bufferAllocator.Allocate(); HoloDebug.Assert(buffer.Data == buffer2.Data); // free it again so stream can get it bufferAllocator.Free(buffer); DenseSampleFloatStream stream = new DenseSampleFloatStream(0, bufferAllocator, sliverSize); stream.Append(new Slice<Sample, float>(new Buf<float>(-6, tempBuffer), sliverSize)); Verify4SliceFloatStream(stream, 0); // have stream drop it; should free buffer stream.Dispose(); // make sure we get it back again buffer2 = bufferAllocator.Allocate(); HoloDebug.Assert(buffer.Data == buffer2.Data); }
public World(AudioGraphImpl audioGraphImpl) { // Each buffer is one second of audio at two stereo channels x 4 bytes per 32-bit-float sample x sample rate. // Allocate 128 of them, arbitrarily. _audioAllocator = new BufferAllocator <float>(2 * 4 * Constants.SampleRateHz, 128, sizeof(float)); _audioGraph = audioGraphImpl; }
protected override void Build(BufferAllocator allocator, ConnectedLayerGroups connectedLayerGroups, NNInitParameters initPars) { InitializeInputAndOutput(connectedLayerGroups); BuildForwardComputation(allocator, connectedLayerGroups, (CPUNNInitParameters)initPars); if (IsBackwardEnabled) BuildBackwardComputation(connectedLayerGroups); }
public void TestMethod1() { var alloc = new BufferAllocator(new byte[8 * 1024 * 40]); var consumers = new Task[100]; for (var i = 0; i < consumers.Length; i++) { var consumer = Task.Run(async() => { var buffer = alloc.AllocateAsync(new Random().Next(4 * 1024, 32 * 1024)); try { if (buffer.Array[buffer.Offset] == 0xff) { throw new Exception("the same buffer was asigned"); } buffer.Array[buffer.Offset] = 0xff; await Task.Delay(200); } finally { buffer.Array[buffer.Offset] = 0x00; alloc.Free(buffer); } }); consumers[i] = consumer; } Task.WaitAll(consumers); }
internal HolofunkBassAsioInput(HolofunkBassAsio bassAsio, int asioChannel, BufferAllocator<float> audioAllocator) { m_bassAsio = bassAsio; m_asioChannel = asioChannel; // buffer one second's worth of audio; that will always be more than we need to look at m_recentPastStream = new DenseSampleFloatStream( default(Time<Sample>), audioAllocator, 1, // input channels are mono maxBufferedDuration: Clock.TimepointRateHz); m_inputToInputPushStreamAsioProc = new ASIOPROC(InputToInputPushStreamAsioProc); // create input push stream; this receives data pushed from ASIO's input, and feeds the mixer m_inputPushStream = (StreamHandle)Bass.BASS_StreamCreatePush( Clock.TimepointRateHz, HolofunkBassAsio.InputChannelCount, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT, new IntPtr(m_asioChannel)); // connect to ASIO input channel CheckError(BassAsio.BASS_ASIO_ChannelEnable( HolofunkBassAsio.IsInputChannel, m_asioChannel, m_inputToInputPushStreamAsioProc, new IntPtr(m_asioChannel))); // join right channel if we have more than one input channel // (this is not generalized for >stereo) if (HolofunkBassAsio.InputChannelCount == 2) { CheckError(BassAsio.BASS_ASIO_ChannelJoin(HolofunkBassAsio.IsInputChannel, 1, m_asioChannel)); } // set format and rate of input channel CheckError(BassAsio.BASS_ASIO_ChannelSetFormat(HolofunkBassAsio.IsInputChannel, m_asioChannel, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT)); CheckError(BassAsio.BASS_ASIO_ChannelSetRate(HolofunkBassAsio.IsInputChannel, m_asioChannel, Clock.TimepointRateHz)); // add input push stream to mixer CheckError(BassMix.BASS_Mixer_StreamAddChannel( (int)m_bassAsio.MixerHStream, (int)m_inputPushStream, BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_MIXER_NORAMPIN)); // set up the input effects (aka microphone effects) m_inputPushEffects = AllEffects.CreateLoopEffectSet(m_inputPushStream, m_bassAsio.BaseForm); // connect peak level meter to input push stream m_plmRec = new DSP_PeakLevelMeter((int)m_inputPushStream, 0); m_plmRec.Notification += new EventHandler(Plm_Rec_Notification); // Register DSPPROC handler for input channel. Make sure to hold the DSPPROC itself. // See documentation for BassAsioHandler.InputChannel m_inputDspProc = new DSPPROC(InputDspProc); // set up our recording DSP -- priority 10 hopefully means "run first first first!" CheckError(Bass.BASS_ChannelSetDSP((int)m_inputPushStream, m_inputDspProc, new IntPtr(0), 10) != 0); }
public Session(Connection clientConnection, BufferAllocator bufferAllocator) { _clientConnection = clientConnection; _bufferAllocator = bufferAllocator; _request = new Request(this); _response = new Response(this); _clientHandler = new ClientHandler(this, _clientConnection); _serverHandler = new ServerHandler(this); }
public void Send(ICopyable data) { /* * Assemble an AHPacket: */ if (_header == null) { AHHeader ahh = new AHHeader(_hops, _ttl, _source, _dest, _options); _header = MemBlock.Copy(new CopyList(PType.Protocol.AH, ahh)); _header_length = _header.Length; } byte[] ah_packet; int packet_length; int packet_offset; //Try to get the shared BufferAllocator, useful when //we don't know how big the data is, which in general //is just as expensive as doing a CopyTo... BufferAllocator ba = Interlocked.Exchange <BufferAllocator>(ref _buf_alloc, null); if (ba != null) { try { ah_packet = ba.Buffer; packet_offset = ba.Offset; int tmp_off = packet_offset; tmp_off += _header.CopyTo(ah_packet, packet_offset); tmp_off += data.CopyTo(ah_packet, tmp_off); packet_length = tmp_off - packet_offset; ba.AdvanceBuffer(packet_length); } catch (System.Exception x) { throw new SendException(false, "could not write the packet, is it too big?", x); } finally { //Put the BA back Interlocked.Exchange <BufferAllocator>(ref _buf_alloc, ba); } } else { //Oh well, someone else is using the buffer, just go ahead //and allocate new memory: packet_offset = 0; packet_length = _header_length + data.Length; ah_packet = new byte[packet_length]; int off_to_data = _header.CopyTo(ah_packet, 0); data.CopyTo(ah_packet, off_to_data); } MemBlock mb_packet = MemBlock.Reference(ah_packet, packet_offset, packet_length); /* * Now we announce this packet, the AHHandler will * handle routing it for us */ _n.HandleData(mb_packet, _from, this); }
internal void InitializeAlgo(BufferAllocator allocator, LearningRule rule, ConnectedLayer[] connectedLayers, CPUNNInitParameters initPars) { Contract.Requires(rule != null); Contract.Requires(connectedLayers != null); Contract.Requires(connectedLayers.Length > 0); Contract.Requires(initPars != null); Rule = rule; ConnectedLayers = connectedLayers; RunParallel = initPars.RunParallel; Ininitalize(allocator); }
public void TestBufferAllocator() { BufferAllocator<float> bufferAllocator = new BufferAllocator<float>(FloatNumSlices * 2048, 1, sizeof(float)); Buf<float> f = bufferAllocator.Allocate(); HoloDebug.Assert(f.Data.Length == FloatSliverSize * 1024 * FloatNumSlices); Buf<float> f2 = bufferAllocator.Allocate(); HoloDebug.Assert(f.Data.Length == f2.Data.Length); bufferAllocator.Free(f2); Buf<float> f3 = bufferAllocator.Allocate(); HoloDebug.Assert(f2.Data == f3.Data); // need to pull from free list first }
private void BuildForwardComputation(BufferAllocator allocator, ConnectedLayerGroups connectedLayerGroups, CPUNNInitParameters initPars) { forwardComputeGroups = new LayerForwardCompute[connectedLayerGroups.Groups.Count][]; for (int groupIndex = 0; groupIndex < connectedLayerGroups.Groups.Count; groupIndex++) { var group = connectedLayerGroups.Groups[groupIndex]; forwardComputeGroups[groupIndex] = new LayerForwardCompute[group.Count]; for (int layerIndex = 0; layerIndex < group.Count; layerIndex++) { forwardComputeGroups[groupIndex][layerIndex] = CreateLayerForwardCompute(group[layerIndex], initPars); } } }
protected void ListenThread() { Thread.CurrentThread.Name = "udp_listen_thread"; BufferAllocator ba = new BufferAllocator(8 + Int16.MaxValue); EndPoint end = new IPEndPoint(IPAddress.Any, 0); int rec_bytes = 0; MonitorLogSwitch(); ProtocolLog.Monitor.SwitchedSetting += MonitorLogSwitch; while (1 == _running) { int max = ba.Capacity; try { rec_bytes = _s.ReceiveFrom(ba.Buffer, ba.Offset, max, SocketFlags.None, ref end); } catch (SocketException x) { if ((1 == _running) && ProtocolLog.UdpEdge.Enabled) { ProtocolLog.Write(ProtocolLog.UdpEdge, x.ToString()); } } if (rec_bytes < 8) { continue; } int remoteid = NumberSerializer.ReadInt(ba.Buffer, ba.Offset); int localid = NumberSerializer.ReadInt(ba.Buffer, ba.Offset + 4); MemBlock packet_buffer = MemBlock.Reference(ba.Buffer, ba.Offset + 8, rec_bytes - 8); ba.AdvanceBuffer(rec_bytes); if (localid < 0) { // Negative ids are control messages HandleControlPacket(remoteid, localid, packet_buffer, end); } else { HandleDataPacket(remoteid, localid, packet_buffer, end, null); } } ProtocolLog.Monitor.SwitchedSetting -= MonitorLogSwitch; //Let everyone know we are out of the loop _listen_finished_event.Set(); _s.Close(); //Allow garbage collection _s = null; }
public unsafe void GetMessageForEventRecord() { var allocator = new BufferAllocator(); var record = new EventRecordBuilder(allocator); record.AddArg(32); var recordPtr = record.Build(); var info = new TraceEventInfoBuilder(allocator); info.EventMessage = "Foo %1 Bar"; info.PropertyCount = 1; info.TopLevelPropertyCount = 1; info.EventPropertyInfos = new[] { new EVENT_PROPERTY_INFO { InType = TDH_IN_TYPE.INT32, OutType = TDH_OUT_TYPE.INT, countAndCountPropertyIndex = 1, lengthAndLengthPropertyIndex = 4 } }; var infoPtr = info.Build(); var context = new ParseTdhContext(); var formatProvider = CultureInfo.InvariantCulture; string message; var sw = new Stopwatch(); var formatter = new NativeTdhFormatter(); sw.Restart(); for (int i = 0; i < 100000; ++i) { var eventInfo = new EventInfo { EventRecord = (IntPtr)recordPtr.Ptr, TraceEventInfo = (IntPtr)infoPtr.Ptr, TraceEventInfoSize = (UIntPtr)infoPtr.Size }; message = formatter.GetMessageForEvent( eventInfo, context, formatProvider); Assert.Equal("Foo 32 Bar", message); } sw.Stop(); output.WriteLine("EMF: {0}", sw.ElapsedMilliseconds); allocator.Dispose(); }
public BlockAllocator(AllocatorManager.AllocatorHandle handle, int budgetInBytes) { m_bufferAllocator = new BufferAllocator(budgetInBytes, ms_BlockSize, handle); m_nextPtr = 0; var blocks = (budgetInBytes + ms_BlockSize - 1) >> ms_Log2BlockSize; m_allocations = new UnsafeIntList(blocks, handle); for (int i = 0; i < blocks; ++i) { m_allocations.Add(0); } m_currentBlockIndex = -1; }
public ChunkBuffer() { //Setup all buffer allocators VertexBuffers = new UniformBuffer(false); BufferAllocators = new BufferAllocator[Sizes.Length]; unsafe { long *buf = (long *)VertexBuffers.Update(); for (int i = 0; i < Sizes.Length; i++) { BufferAllocators[i] = new BufferAllocator(Sizes[i], Counts[i], false, PixelInternalFormat.Rgba8ui); buf[i * 2] = BufferAllocators[i].BufferTex.View.GetTextureHandle().SetResidency(Residency.Resident); } VertexBuffers.UpdateDone(); } }
public SocketState(TcpEdgeListener tel) { _sock_to_rs = new Hashtable(); _sock_to_constate = new ListDictionary(); _con_socks = new ArrayList(); ListenSock = tel._listen_sock; _socks_to_send = new ArrayList(); AllSockets = new ArrayList(); ReadSocks = new ArrayList(); ErrorSocks = new ArrayList(); WriteSocks = new ArrayList(); Run = true; /* Use a shared BufferAllocator for all Edges */ BA = new BufferAllocator(2 + Int16.MaxValue); ListenSock.Listen(10); TEL = tel; }
public MultiDrawIndirectMesh(GL gl, nuint allocatorSize, DrawElementsType drawElementsType, Layer layers = Layer.Layer0) { const nuint reasonable_max_object_count = 21_000u; ID = Guid.NewGuid(); Layer = layers; _GL = gl; _CommandBuffer = new BufferObject <DrawElementsIndirectCommand>(gl); _BufferAllocator = new BufferAllocator(gl, allocatorSize); _VertexArrayObject = new VertexArrayObject(gl); _ModelBuffer = new BufferObject <Matrix4x4>(gl, reasonable_max_object_count, BufferStorageMask.MapWriteBit); _VertexArrayObject.AllocateVertexBufferBinding(0u, _BufferAllocator); _VertexArrayObject.AllocateVertexBufferBinding(1u, _ModelBuffer, 0, 1u); _DrawElementsType = drawElementsType; }
public WeightRelatedValues(BufferAllocator allocator, ConnectedLayer[] layers) { Contract.Requires(allocator != null); Contract.Requires(layers != null); Contract.Requires(layers.Length > 0); buffers = new IntRange[layers.Length][]; for (int layerIndex = 0; layerIndex < layers.Length; layerIndex++) { var wib = layers[layerIndex].WeightedInputBuffers; buffers[layerIndex] = new IntRange[wib.Length]; for (int buffIndex = 0; buffIndex < wib.Length; buffIndex++) { buffers[layerIndex][buffIndex] = allocator.Alloc(wib[buffIndex].WeightBuffer.Size); } } this.layers = layers; }
public SimulationEdgeListener(int id, double loss_prob, TAAuthorizer ta_auth, bool use_delay) { _edges = new Hashtable(); _use_delay = use_delay; _sync = new object(); _ba = new BufferAllocator(Int16.MaxValue); _listener_id = id; _ploss_prob = loss_prob; if (ta_auth == null) { _ta_auth = new ConstantAuthorizer(TAAuthorizer.Decision.Allow); } else { _ta_auth = ta_auth; } _tas = new ArrayList(); _tas.Add(TransportAddressFactory.CreateInstance("b.s://" + _listener_id)); _rand = new Random(); }
public void TestLimitedBufferingStream() { const int sliverSize = 4; // 4 floats = 16 bytes const int floatNumSlices = 11; // 11 slices per buffer, to test various cases BufferAllocator<float> bufferAllocator = new BufferAllocator<float>(sliverSize * floatNumSlices, 1, sizeof(float)); float[] tempBuffer = AllocateSmall4FloatArray(20, sliverSize); DenseSampleFloatStream stream = new DenseSampleFloatStream(0, bufferAllocator, sliverSize, 5); stream.Append(new Slice<Sample, float>(new Buf<float>(-7, tempBuffer), 0, 11, sliverSize)); HoloDebug.Assert(stream.DiscreteDuration == 5); Slice<Sample, float> slice = stream.GetNextSliceAt(stream.DiscreteInterval); HoloDebug.Assert(slice[0, 0] == 6f); stream.Append(new Slice<Sample, float>(new Buf<float>(-8, tempBuffer), 11, 5, sliverSize)); HoloDebug.Assert(stream.DiscreteDuration == 5); HoloDebug.Assert(stream.InitialTime == 11); slice = stream.GetNextSliceAt(stream.DiscreteInterval); HoloDebug.Assert(slice[0, 0] == 11f); }
/// <summary>The thread acting as the ISource for Ethernet, this is where /// reading of the TAP is performed. Use Subscribe to receive the packets /// coming from here.</summary> /// <remarks>The same max MTU byte array is always read into. This is then /// copied to a minimum sized MemBlock and send to the subscriber. </remarks> protected void ReadLoop() { byte[] read_buffer = new byte[MTU]; BufferAllocator ba = new BufferAllocator(MTU, 1.1); while (_running) { int length = -1; try { length = _tap.Read(read_buffer); } catch (ThreadInterruptedException x) { if (_running && ProtocolLog.Exceptions.Enabled) { ProtocolLog.Write(ProtocolLog.Exceptions, x.ToString()); } } catch (Exception e) { ProtocolLog.WriteIf(ProtocolLog.Exceptions, e.ToString()); } if (length == 0 || length == -1) { ProtocolLog.WriteIf(IpopLog.TapLog, "Couldn't read TAP"); continue; } Array.Copy(read_buffer, 0, ba.Buffer, ba.Offset, length); MemBlock packet = MemBlock.Reference(ba.Buffer, ba.Offset, length); ba.AdvanceBuffer(length); Subscriber s = _sub; if (s != null) { try { s.Handle(packet, this); } catch (Exception e) { ProtocolLog.WriteIf(ProtocolLog.Exceptions, e.ToString()); } } } }
public ReceiveState(TcpEdge e, BufferAllocator ba) { Edge = e; _s = e.Socket; _ba = ba; }
public TraceEventInfoBuilder(BufferAllocator allocator) { this.allocator = allocator; }
static SimulationEdgeListener() { _el_map = new Dictionary<TransportAddress.TAType, Dictionary<int, SimulationEdgeListener>>(); _ba = new BufferAllocator(Int16.MaxValue); _rand = Node.SimulatorRandom; }
/** * This is a System.Threading.ThreadStart delegate * We loop waiting for edges that need to send, * or data on the socket. * * This is the only thread that can touch the socket, * therefore, we do not need to lock the socket. */ protected void ListenThread() { Thread.CurrentThread.Name = "udp_listen_thread"; BufferAllocator ba = new BufferAllocator(8 + Int16.MaxValue); EndPoint end = new IPEndPoint(IPAddress.Any, 0); DateTime last_debug = DateTime.UtcNow; int debug_period = 5000; bool logging = ProtocolLog.Monitor.Enabled; int rec_bytes = 0; while(1 == _running) { if(logging) { DateTime now = DateTime.UtcNow; if(last_debug.AddMilliseconds(debug_period) < now) { last_debug = now; ProtocolLog.Write(ProtocolLog.Monitor, String.Format("I am alive: {0}", now)); } } int max = ba.Capacity; try { rec_bytes = _s.ReceiveFrom(ba.Buffer, ba.Offset, max, SocketFlags.None, ref end); } catch(SocketException x) { if((1 == _running) && ProtocolLog.UdpEdge.Enabled) { ProtocolLog.Write(ProtocolLog.UdpEdge, x.ToString()); } } if(rec_bytes < 8) { continue; } int remoteid = NumberSerializer.ReadInt(ba.Buffer, ba.Offset); int localid = NumberSerializer.ReadInt(ba.Buffer, ba.Offset + 4); MemBlock packet_buffer = MemBlock.Reference(ba.Buffer, ba.Offset + 8, rec_bytes - 8); ba.AdvanceBuffer(rec_bytes); if( localid < 0 ) { // Negative ids are control messages HandleControlPacket(remoteid, localid, packet_buffer, null); } else { HandleDataPacket(remoteid, localid, packet_buffer, end, null); } } //Let everyone know we are out of the loop _listen_finished_event.Set(); _s.Close(); //Allow garbage collection _s = null; }
protected virtual void Ininitalize(BufferAllocator allocator) { }
internal void InitializeAlgo(BufferAllocator allocator, LearningRule learningRule, ConnectedLayer[] connectedLayer) { throw new NotImplementedException(); }
protected override void InitializeLearningAlgorithms(BufferAllocator allocator, LearningLayerGroups learningLayerGroups, NNInitParameters initPars) { algorithms = new LearningAlgorithm[learningLayerGroups.Count]; var biAlgos = new LinkedList<LearningAlgorithm>(); var aeAlgos = new LinkedList<LearningAlgorithm>(); int idx = 0; foreach (var group in learningLayerGroups) { var algo = CreateAlgorithmForRule(group.Rule); algo.InitializeAlgo(allocator, group.Rule, group.ConnectedLayers.ToArray(), (CPUNNInitParameters)initPars); algorithms[idx++] = algo; if (algo.Rule.IsBeforeIterationRule) biAlgos.AddLast(algo); if (algo.Rule.IsErrorBasedRule) aeAlgos.AddLast(algo); } beforeIterationAlgorithms = biAlgos.ToArray(); errorBasedAlgorithms = aeAlgos.ToArray(); }
public void TestStreamAppending() { const int sliverSize = 4; // 4 floats = 16 bytes const int floatNumSlices = 11; // 11 slices per buffer, to test various cases BufferAllocator<float> bufferAllocator = new BufferAllocator<float>(sliverSize * floatNumSlices, 1, sizeof(float)); float[] buffer = AllocateSmall4FloatArray(floatNumSlices, sliverSize); DenseSampleFloatStream stream = new DenseSampleFloatStream(0, bufferAllocator, sliverSize); unsafe { fixed (float* f = buffer) { IntPtr pf = new IntPtr(f); stream.Append(floatNumSlices, pf); } } HoloDebug.Assert(stream.DiscreteDuration == floatNumSlices); HoloDebug.Assert(Verify4SliceFloatStream(stream, 0) == 11); // clear original buffer to test copying back into it for (int i = 0; i < buffer.Length; i++) { buffer[i] = 0; } unsafe { fixed (float* f = buffer) { IntPtr pf = new IntPtr(f); stream.CopyTo(stream.DiscreteInterval, pf); } } DenseSampleFloatStream stream2 = new DenseSampleFloatStream(0, bufferAllocator, sliverSize); stream2.Append(new Slice<Sample, float>(new Buf<float>(-3, buffer), sliverSize)); HoloDebug.Assert(Verify4SliceFloatStream(stream2, 0) == 11); }
public EotStreamReader(Stream stream, BufferAllocator bufferAllocator) : base(stream, bufferAllocator) { }
public void SetUp() { //Create space for up to 1000 objects _bufferAllocator = new BufferAllocator(1000 * 512, 512); }
public HttpProxy() { _listener = new TcpListener(_port); _bufferAllocator = new BufferAllocator(new byte[1024 * 1024]); _listener.ConnectionRequested += OnConnectionRequested; }
static AHSender() { SenderFactory.Register("ah", CreateInstance); _buf_alloc = new BufferAllocator(System.UInt16.MaxValue); }
public void HandleData(AHHeader header, ICopyable payload, ISender ret_path, object st) { AHState state = _state; //Read the state, it can't change after the read Connection next_con; //Check to see if we can use a Leaf connection: int dest_idx = state.Leafs.IndexOf(header.Destination); if (dest_idx >= 0) { next_con = state.Leafs[dest_idx]; } else { var alg = state.GetRoutingAlgo(header); Pair <Connection, bool> result = alg.NextConnection(ret_path as Edge, header); if (result.Second) { //Send a response exactly back to the node that sent to us var resp_send = new AHSender(_n, ret_path, header.Source, AHSender.DefaultTTLFor(_n.NetworkSize), AHHeader.Options.Exact, header.Hops); MemBlock data = payload as MemBlock; if (data == null) { // Try to get the shared BufferAllocator, useful when we don't know // how big the data is, which in general is just as expensive as // doing a CopyTo... BufferAllocator ba = Interlocked.Exchange <BufferAllocator>(ref _ba, null); if (ba != null) { try { int length = payload.CopyTo(ba.Buffer, ba.Offset); data = MemBlock.Reference(ba.Buffer, ba.Offset, length); ba.AdvanceBuffer(length); } catch (System.Exception x) { throw new SendException(false, "could not write the packet, is it too big?", x); } finally { Interlocked.Exchange <BufferAllocator>(ref _ba, ba); } } else { data = MemBlock.Copy(payload); } } _n.HandleData(data, resp_send, this); } next_con = result.First; } //Send it on: if (next_con != null) { //Now we do the sending: var new_packet = new CopyList(PType.Protocol.AH, header.IncrementHops(), payload); try { next_con.State.Edge.Send(new_packet); } catch (SendException) { //Just drop the packet... } } }
protected override void Built(BufferAllocator allocator, ConnectedLayerGroups connectedLayerGroups, NNInitParameters initPars) { // Create buffer: oclValueBuffer = oclContext.CreateBuffer<float>(allocator.Size, ComputeMemoryFlags.ReadWrite); // Fill with zeros: // TODO: Add this stuff to and OpenCLUtils class or sumthin int size = 1000; int remain = allocator.Size % size; float[] zeros = new float[size]; if (remain != 0) oclQueue.Write(oclValueBuffer, zeros, 0, remain, false); for (int i = remain; i < allocator.Size; i += size) { oclQueue.Write(oclValueBuffer, zeros, i, size, false); } oclQueue.ComputeCommandQueue.Finish(); }
public void TestSparseSampleByteStream() { const int sliverSize = 2 * 2 * 4; // uncompressed 2x2 RGBA image... worst case const int bufferSlivers = 10; BufferAllocator<byte> allocator = new BufferAllocator<byte>(sliverSize * bufferSlivers, 1, sizeof(float)); byte[] appendBuffer = new byte[sliverSize]; for (int i = 0; i < sliverSize; i++) { appendBuffer[i] = (byte)i; } SparseSampleByteStream stream = new SparseSampleByteStream(10, allocator, sliverSize); stream.Append(11, new Slice<Frame, byte>(new Buf<byte>(-9, appendBuffer), sliverSize)); // now let's get it back out Slice<Frame, byte> slice = stream.GetClosestSliver(11); HoloDebug.Assert(slice.Duration == 1); HoloDebug.Assert(slice.SliverSize == sliverSize); for (int i = 0; i < sliverSize; i++) { HoloDebug.Assert(slice[0, i] == (byte)i); } // now let's copy it to intptr byte[] target = new byte[sliverSize]; unsafe { fixed (byte* p = target) { IntPtr pp = new IntPtr(p); stream.CopyTo(11, pp); } } for (int i = 0; i < sliverSize; i++) { HoloDebug.Assert(target[i] == (byte)i); } SparseSampleByteStream stream2 = new SparseSampleByteStream(10, allocator, sliverSize); unsafe { fixed (byte* p = target) { IntPtr pp = new IntPtr(p); stream2.Append(11, pp); } } Slice<Frame, byte> slice2 = stream2.GetClosestSliver(12); HoloDebug.Assert(slice2.Duration == 1); HoloDebug.Assert(slice2.SliverSize == sliverSize); for (int i = 0; i < sliverSize; i++) { HoloDebug.Assert(slice2[0, i] == (byte)i); } // now verify looping and shutting work as expected for (int i = 0; i < appendBuffer.Length; i++) { appendBuffer[i] += (byte)appendBuffer.Length; } stream2.Append(21, new Slice<Frame, byte>(new Buf<byte>(-10, appendBuffer), sliverSize)); Slice<Frame, byte> slice3 = stream2.GetClosestSliver(12); HoloDebug.Assert(slice3.Duration == 1); HoloDebug.Assert(slice3.SliverSize == sliverSize); HoloDebug.Assert(slice3[0, 0] == (byte)0); Slice<Frame, byte> slice4 = stream2.GetClosestSliver(22); HoloDebug.Assert(slice4.Duration == 1); HoloDebug.Assert(slice4.SliverSize == sliverSize); HoloDebug.Assert(slice4[0, 0] == (byte)sliverSize); stream2.Shut((ContinuousDuration)20); // now the closest sliver to 32 should be the first sliver Slice<Frame, byte> slice5 = stream2.GetClosestSliver(32); HoloDebug.Assert(slice5.Duration == 1); HoloDebug.Assert(slice5.SliverSize == sliverSize); HoloDebug.Assert(slice5[0, 0] == (byte)0); // and 42, the second Slice<Frame, byte> slice6 = stream2.GetClosestSliver(42); HoloDebug.Assert(slice6.Duration == 1); HoloDebug.Assert(slice6.SliverSize == sliverSize); HoloDebug.Assert(slice6[0, 0] == (byte)sliverSize); }
protected override void InitializeLearningAlgorithms(BufferAllocator allocator, Learning.LearningLayerGroups learningLayerGroups, NNInitParameters initPars) { }
static SimulationEdgeListener() { _listener_map = new Dictionary<int, SimulationEdgeListener>(); _ba = new BufferAllocator(Int16.MaxValue); }
protected override void Built(BufferAllocator allocator, ConnectedLayerGroups connectedLayerGroups, NNInitParameters initPars) { // Create buffer: valueBuffer = new float[allocator.Size]; // RTLR: if ((StructuralElementFlags & NNStructuralElement.RTLRInformation) != 0) { pValProp = new PValuePropagator(connectedLayerGroups.IndexTable, forwardComputeGroups.SelectMany(g => g)); } }
/// <summary>Allows the game to perform any initialization it needs to before starting to run.</summary> /// <remarks>This is where it can query for any required services and load any non-graphic /// related content. Calling base.Initialize will enumerate through any components /// and initialize them as well.</remarks> protected override void Initialize() { new Test(GraphicsDevice).RunAllTests(); // HORRIBLE HACK: just ensure the statics are initialized string s = PlayerEffectSpaceModel.EffectSettings[0].LeftLabel; m_audioAllocator = new BufferAllocator<float>(2 * 4 * Clock.TimepointRateHz, 128, sizeof(float)); m_holofunkBass = new HolofunkBass(m_clock, m_audioAllocator); m_holofunkBass.StartASIO(); m_kinect = new HolofunKinect(GraphicsDevice, BodyFrameUpdate); m_viewportSize = m_kinect.ViewportSize; m_videoAllocator = new BufferAllocator<byte>(64 * MagicNumbers.HeadCaptureBytes, 128, 1); base.Initialize(); // oh dear m_holofunkBass.SetBaseForm(m_primaryForm, MagicNumbers.MaxStreamCount); Window.Title = "Holofunk Alpha"; Window.AllowUserResizing = true; /* object nativeWindow = Window.NativeWindow; System.Windows.Forms.Form asForm = nativeWindow as System.Windows.Forms.Form; asForm.SetDesktopBounds(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height); //asForm.SetDesktopBounds(100, 100, (int)(m_viewportSize.X * 2), (int)(m_viewportSize.Y * 2)); */ }
public void TestStream() { BufferAllocator<float> bufferAllocator = new BufferAllocator<float>(FloatNumSlices * 2048, 1, sizeof(float)); DenseSampleFloatStream stream = new DenseSampleFloatStream(0, bufferAllocator, FloatSliverSize); HoloDebug.Assert(stream.DiscreteDuration == 0); var interval = new Interval<Sample>(0, 10); Slice<Sample, float> firstSlice = stream.GetNextSliceAt(interval); HoloDebug.Assert(firstSlice.IsEmpty()); // Now let's fill a float array... float[] buffer = new float[FloatNumSlices * FloatSliverSize]; Duration<Sample> floatNumSlicesDuration = FloatNumSlices; Slice<Sample, float> tempSlice = new Slice<Sample, float>(new Buf<float>(-1, buffer), FloatSliverSize); PopulateFloatSlice(tempSlice); // now append in chunks stream.Append(tempSlice.SubsliceOfDuration(tempSlice.Duration / 2)); stream.Append(tempSlice.SubsliceStartingAt(tempSlice.Duration / 2)); HoloDebug.Assert(stream.InitialTime == 0); HoloDebug.Assert(stream.DiscreteDuration == FloatNumSlices); Slice<Sample, float> theSlice = stream.GetNextSliceAt(stream.DiscreteInterval); VerifySlice(theSlice); HoloDebug.Assert(theSlice.Duration == floatNumSlicesDuration); }
public void TestStreamSlicing() { const int sliverSize = 4; // 4 floats = 16 bytes const int floatNumSlices = 11; // 11 slices per buffer, to test various cases BufferAllocator<float> bufferAllocator = new BufferAllocator<float>(sliverSize * floatNumSlices, 1, sizeof(float)); float[] buffer = AllocateSmall4FloatArray(floatNumSlices * 2, sliverSize); DenseSampleFloatStream stream = new DenseSampleFloatStream(0, bufferAllocator, sliverSize); stream.Append(new Slice<Sample, float>(new Buf<float>(-4, buffer), sliverSize)); // test getting slices from existing stream Slice<Sample, float> beforeFirst = stream.GetNextSliceAt(new Interval<Sample>((-2), 4)); // should return slice with duration 2 HoloDebug.Assert(beforeFirst.Duration == 2); Slice<Sample, float> afterLast = stream.GetNextSliceAt(new Interval<Sample>(19, 5)); HoloDebug.Assert(afterLast.Duration == 3); // now get slice across the buffer boundary, verify it is split as expected Interval<Sample> splitInterval = new Interval<Sample>(7, 8); Slice<Sample, float> beforeSplit = stream.GetNextSliceAt(splitInterval); HoloDebug.Assert(beforeSplit.Duration == 4); Slice<Sample, float> afterSplit = stream.GetNextSliceAt(splitInterval.SubintervalStartingAt(beforeSplit.Duration)); HoloDebug.Assert(afterSplit.Duration == beforeSplit.Duration); float lastBefore = beforeSplit[3, 0]; float firstAfter = afterSplit[0, 0]; HoloDebug.Assert(lastBefore + 1 == firstAfter); float[] testStrideCopy = new float[] { 0, 0, 1, 1, 0, 0, 0, 0, 2, 2, 0, 0, }; stream.AppendSliver(testStrideCopy, 2, 2, 6, 2); Slice<Sample, float> lastSliver = stream.GetNextSliceAt(new Interval<Sample>(22, 1)); HoloDebug.Assert(lastSliver.Duration == 1); HoloDebug.Assert(lastSliver[0, 0] == 1f); HoloDebug.Assert(lastSliver[0, 1] == 1f); HoloDebug.Assert(lastSliver[0, 2] == 2f); HoloDebug.Assert(lastSliver[0, 3] == 2f); Slice<Sample, float> firstSlice = stream.GetNextSliceAt(new Interval<Sample>(-2, 100)); HoloDebug.Assert(firstSlice.Duration == 11); }
protected void ListenThread() { Thread.CurrentThread.Name = "udp_listen_thread"; BufferAllocator ba = new BufferAllocator(8 + Int16.MaxValue); EndPoint end = new IPEndPoint(IPAddress.Any, 0); int rec_bytes = 0; MonitorLogSwitch(); ProtocolLog.Monitor.SwitchedSetting += MonitorLogSwitch; while(1 == _running) { int max = ba.Capacity; try { rec_bytes = _s.ReceiveFrom(ba.Buffer, ba.Offset, max, SocketFlags.None, ref end); } catch(SocketException x) { if((1 == _running) && ProtocolLog.UdpEdge.Enabled) { ProtocolLog.Write(ProtocolLog.UdpEdge, x.ToString()); } } if(rec_bytes < 8) { continue; } int remoteid = NumberSerializer.ReadInt(ba.Buffer, ba.Offset); int localid = NumberSerializer.ReadInt(ba.Buffer, ba.Offset + 4); MemBlock packet_buffer = MemBlock.Reference(ba.Buffer, ba.Offset + 8, rec_bytes - 8); ba.AdvanceBuffer(rec_bytes); if( localid < 0 ) { // Negative ids are control messages HandleControlPacket(remoteid, localid, packet_buffer, end); } else { HandleDataPacket(remoteid, localid, packet_buffer, end, null); } } ProtocolLog.Monitor.SwitchedSetting -= MonitorLogSwitch; //Let everyone know we are out of the loop _listen_finished_event.Set(); _s.Close(); //Allow garbage collection _s = null; }
static SimulationEdgeListener() { _el_map = new Dictionary <TransportAddress.TAType, Dictionary <int, SimulationEdgeListener> >(); _ba = new BufferAllocator(Int16.MaxValue); _rand = Node.SimulatorRandom; }
/** * This is a System.Threading.ThreadStart delegate * We loop waiting for edges that need to send, * or data on the socket. * * This is the only thread that can touch the socket, * therefore, we do not need to lock the socket. */ protected void ListenThread() { Thread.CurrentThread.Name = "udp_listen_thread"; BufferAllocator ba = new BufferAllocator(8 + Int16.MaxValue); EndPoint end = new IPEndPoint(IPAddress.Any, 0); DateTime last_debug = DateTime.UtcNow; int debug_period = 5000; bool logging = ProtocolLog.Monitor.Enabled; int rec_bytes = 0; while (1 == _running) { if (logging) { DateTime now = DateTime.UtcNow; if (last_debug.AddMilliseconds(debug_period) < now) { last_debug = now; ProtocolLog.Write(ProtocolLog.Monitor, String.Format("I am alive: {0}", now)); } } int max = ba.Capacity; try { rec_bytes = _s.ReceiveFrom(ba.Buffer, ba.Offset, max, SocketFlags.None, ref end); } catch (SocketException x) { if ((1 == _running) && ProtocolLog.UdpEdge.Enabled) { ProtocolLog.Write(ProtocolLog.UdpEdge, x.ToString()); } } if (rec_bytes < 8) { continue; } int remoteid = NumberSerializer.ReadInt(ba.Buffer, ba.Offset); int localid = NumberSerializer.ReadInt(ba.Buffer, ba.Offset + 4); MemBlock packet_buffer = MemBlock.Reference(ba.Buffer, ba.Offset + 8, rec_bytes - 8); ba.AdvanceBuffer(rec_bytes); if (localid < 0) { // Negative ids are control messages HandleControlPacket(remoteid, localid, packet_buffer, null); } else { HandleDataPacket(remoteid, localid, packet_buffer, end, null); } } //Let everyone know we are out of the loop _listen_finished_event.Set(); _s.Close(); //Allow garbage collection _s = null; }
public void TestStreamShutting() { const int sliverSize = 4; // 4 floats = 16 bytes const int floatNumSlices = 11; // 11 slices per buffer, to test various cases BufferAllocator<float> bufferAllocator = new BufferAllocator<float>(sliverSize * floatNumSlices, 1, sizeof(float)); float continuousDuration = 2.4f; int discreteDuration = (int)Math.Round(continuousDuration + 1); float[] buffer = AllocateSmall4FloatArray(discreteDuration, sliverSize); DenseSampleFloatStream stream = new DenseSampleFloatStream(0, bufferAllocator, sliverSize, useContinuousLoopingMapper: true); stream.Append(new Slice<Sample, float>(new Buf<float>(-5, buffer), sliverSize)); // OK, time to get this fractional business right. stream.Shut((ContinuousDuration)continuousDuration); HoloDebug.Assert(stream.IsShut); // now test looping Interval<Sample> interval = new Interval<Sample>(0, 10); // we expect this to be [0, 1, 2, 0, 1, 0, 1, 2, 0, 1] // or rather, [0>3], [0>2], [0>3], [0>2] Slice<Sample, float> slice = stream.GetNextSliceAt(interval); HoloDebug.Assert(slice.Duration == 3); HoloDebug.Assert(slice[0, 0] == 0f); HoloDebug.Assert(slice[2, 0] == 2f); interval = interval.SubintervalStartingAt(slice.Duration); slice = stream.GetNextSliceAt(interval); HoloDebug.Assert(slice.Duration == 2); HoloDebug.Assert(slice[0, 0] == 0f); HoloDebug.Assert(slice[1, 0] == 1f); interval = interval.SubintervalStartingAt(slice.Duration); slice = stream.GetNextSliceAt(interval); HoloDebug.Assert(slice.Duration == 3); HoloDebug.Assert(slice[0, 0] == 0f); HoloDebug.Assert(slice[2, 0] == 2f); interval = interval.SubintervalStartingAt(slice.Duration); slice = stream.GetNextSliceAt(interval); HoloDebug.Assert(slice.Duration == 2); HoloDebug.Assert(slice[0, 0] == 0f); HoloDebug.Assert(slice[1, 0] == 1f); interval = interval.SubintervalStartingAt(slice.Duration); HoloDebug.Assert(interval.IsEmpty); DenseSampleFloatStream stream2 = new DenseSampleFloatStream(0, bufferAllocator, sliverSize, useContinuousLoopingMapper: false); stream2.Append(new Slice<Sample, float>(new Buf<float>(-5, buffer), sliverSize)); stream2.Shut((ContinuousDuration)continuousDuration); interval = new Interval<Sample>(0, 10); slice = stream2.GetNextSliceAt(interval); HoloDebug.Assert(slice.Duration == 3); HoloDebug.Assert(slice[0, 0] == 0f); HoloDebug.Assert(slice[2, 0] == 2f); interval = interval.SubintervalStartingAt(slice.Duration); slice = stream2.GetNextSliceAt(interval); HoloDebug.Assert(slice.Duration == 3); HoloDebug.Assert(slice[0, 0] == 0f); HoloDebug.Assert(slice[1, 0] == 1f); interval = interval.SubintervalStartingAt(slice.Duration); slice = stream2.GetNextSliceAt(interval); HoloDebug.Assert(slice.Duration == 3); HoloDebug.Assert(slice[0, 0] == 0f); HoloDebug.Assert(slice[2, 0] == 2f); interval = interval.SubintervalStartingAt(slice.Duration); slice = stream2.GetNextSliceAt(interval); HoloDebug.Assert(slice.Duration == 1); HoloDebug.Assert(slice[0, 0] == 0f); }
public VoxelCache(string cacheName) : base(cacheName) { IndexBuffer = new BufferAllocator(cacheName, VoxelConstants.IndexBlockSz, VoxelConstants.IndexBlockCnt, BufferUsage.Index, ImageFormat.R8G8B8A8UInt); }
public void TestStreamChunky() { const int sliverSize = 4; // 4 floats = 16 bytes const int floatNumSlices = 11; // 11 slices per buffer, to test various cases const int biggestChunk = 5; // max size of slice to copy in middle loop BufferAllocator<float> bufferAllocator = new BufferAllocator<float>(sliverSize * floatNumSlices, 1, sizeof(float)); DenseSampleFloatStream stream = new DenseSampleFloatStream(0, bufferAllocator, sliverSize); HoloDebug.Assert(stream.DiscreteDuration == 0); float f = 0; float[] tinyBuffer = new float[biggestChunk * sliverSize]; for (int i = 0; i < 100; i++) { for (int c = 1; c <= 5; c++) { for (int j = 0; j < c; j++) { tinyBuffer[j * sliverSize] = f; tinyBuffer[j * sliverSize + 1] = f + 0.25f; tinyBuffer[j * sliverSize + 2] = f + 0.5f; tinyBuffer[j * sliverSize + 3] = f + 0.75f; f++; } Slice<Sample, float> tempSlice = new Slice<Sample, float>( new Buf<float>(-2, tinyBuffer), 0, c, sliverSize); stream.Append(tempSlice); } } // Now after this we will need a verification loop. BufferAllocator<float> bigBufferAllocator = new BufferAllocator<float>(sliverSize * 1024, 1, sizeof(float)); DenseSampleFloatStream bigStream = new DenseSampleFloatStream(0, bigBufferAllocator, sliverSize); stream.CopyTo(stream.DiscreteInterval, bigStream); HoloDebug.Assert(Verify4SliceFloatStream(stream, 0) == 1500); HoloDebug.Assert(Verify4SliceFloatStream(bigStream, 0) == 1500); DenseSampleFloatStream stream2 = new DenseSampleFloatStream(0, bufferAllocator, sliverSize); bigStream.CopyTo(bigStream.DiscreteInterval, stream2); HoloDebug.Assert(Verify4SliceFloatStream(stream2, 0) == 1500); }
static SimulationEdgeListener() { _listener_map = new Dictionary <int, SimulationEdgeListener>(); _ba = new BufferAllocator(Int16.MaxValue); }
public EventRecordBuilder(BufferAllocator allocator) { this.allocator = allocator; }