private static MemoryOperations memory; //avoid gc static void Main(string[] args) { RPCAbleMethods.Load(); NetPeerConfiguration config = new NetPeerConfiguration("of_masterserver") { Port = PORT, MaximumConnections = (2 ^ 32 - 1), AcceptIncomingConnections = true, }; peer = new NetServer(config); peer.Start(); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("> Server started, server version: " + VERSION); Console.ForegroundColor = ConsoleColor.White; memory = new MemoryOperations(); ServerLoop.StartServerLoop(peer); while (ServerLoop.EnabledLooping) { Thread.Sleep(1000); } }
protected static byte *Write(byte *dest, params byte[] data) { int size = data.Length; fixed(byte *src = data) MemoryOperations.BlockCopy(src, dest, size); return(dest + size); }
static unsafe bool _EqualsUnsafeCore(byte[] x, byte[] y) { var n = x.Length; if (n == 0) { return(true); fixed(byte *px = x, py = y) return(MemoryOperations.BlockEquals(px, py, n)); }
public static uint[] Cpuid(uint req_no) { uint[] buf = new uint[4]; unsafe { _Cpuid(req_no, (uint *)MemoryOperations.GetInternalArray(buf)); } return(buf); }
/// <summary> /// Overwrites a channel of a sample of the buffer. /// </summary> /// <param name="sample">A pointer to the first byte of the channel value to read from.</param> /// <param name="index">The index of the target sample to write to.</param> /// <param name="channel">The index of the channel to write to.</param> public unsafe void WriteChannel(byte *sample, int index, int channel) { if (mode != OperationMode.Convert) { int sampleStart = index * target.Format.Size + channel * target.Format.ChannelSize; fixed(byte *destPtr = target.RawData) { MemoryOperations.Copy(destPtr + sampleStart, sample, target.Format.ChannelSize); } } else { // Read the sample to the buffer for (int j = 0; j < writeFormat.ChannelSize; j++) { buffer[j] = sample[j]; } fixed(byte *bufferPtr = buffer, destPtr = target.RawData) { // Pass 1: Change the bit-depth if (writeFormat.BitDepth != target.Format.BitDepth) { ChangeBitDepth( bufferPtr, 1, // one channel writeFormat.BitDepth, target.Format.BitDepth ); } // Pass 2: Change the sign if (shouldChangeSign) { if (shouldMakeSigned) { MakeSigned(bufferPtr, target.Format); } else { MakeUnsigned(bufferPtr, target.Format); } } int sampleStart = index * target.Format.Size + channel * target.Format.ChannelSize; MemoryOperations.Copy(destPtr + sampleStart, bufferPtr, target.Format.ChannelSize); } } }
public static void ReloadBalanceData(NetIncomingMessage message) { string AdminLogin = message.ReadString(); string AdminPassword = message.ReadString(); string BanNickname = message.ReadString(); try { PlayerInfo request = MemoryOperations.PlayersData.Keys.FirstOrDefault(x => x.Nickname == AdminLogin); if (request.Password == AdminPassword && request.AccessLevel >= 16) { MemoryOperations.LoadGameBalance(Program.PATH_BALANCE_FILE); Commands.BroadcastBalanceData(); } } catch { } }
private static void Shutdown(NetIncomingMessage message) { string AdminLogin = message.ReadString(); string AdminPassword = message.ReadString(); Console.WriteLine("Shutdown"); try { PlayerInfo request = MemoryOperations.PlayersData.Keys.FirstOrDefault(x => x.Nickname == AdminLogin); if (request.Password == AdminPassword && request.AccessLevel >= 16) { MemoryOperations.RefreshPlayersAccountsInMemory(0); ServerLoop.CloseLooping(); } } catch { Environment.Exit(0); } }
private void TestByteArrayCopy(int size) { byte[] src = new byte[size]; byte[] dst = new byte[size]; mDebugger.Send($"Start Copy of {size} bytes"); MemoryOperations.Fill(src, 42); mDebugger.Send("Copy Start"); MemoryOperations.Copy(dst, src); mDebugger.Send("Copy End"); Assert.AreEqual(src, dst, $"Copy failed Array src and dst with size {size} are not equals"); mDebugger.Send("End"); }
private void TestIntArrayCopy(int size) { int[] src = new int[size]; int[] dst = new int[size]; mDebugger.Send($"Start Copy of {size} integers"); MemoryOperations.Fill(src, 42); mDebugger.Send("Copy Start"); MemoryOperations.Copy(dst, src); mDebugger.Send("Copy End"); Assert.IsTrue(AreArrayEquals(src, dst), $"Copy failed Array src and dst with size {size} are not equals"); mDebugger.Send("End"); }
private void HandleInterrupt(ref INTs.IRQContext aContext) { ushort sr = pTransferStatus.Word; if ((sr & IRQ_LVBCI) > 0) { // Last Valid Buffer interrupt pTransferStatus.Word = IRQ_LVBCI; } else if ((sr & IRQ_BCIS) > 0) { // Load a buffer ahead int next = lastValidIdx + 1; if (next >= BUFFER_COUNT) { next -= BUFFER_COUNT; } BufferProvider.RequestBuffer(transferBuffer); fixed(byte *mainBufPtr = transferBuffer.RawData) { MemoryOperations.Copy( dest: bufferDescriptorList[next].pointer, src: mainBufPtr, size: bufferSizeBytes ); } // Set the index to the current one lastValidIdx++; if (lastValidIdx == BUFFER_COUNT) { lastValidIdx = 0; } pLastValidEntry.Byte = lastValidIdx; pTransferStatus.Word = IRQ_BCIS; } else if ((sr & IRQ_FIFO_ERROR) > 0) { pTransferStatus.Word = IRQ_FIFO_ERROR; } }
public unsafe void Execute(string parameter = null) { if (parameter == null || !int.TryParse(parameter, out var length)) { length = 64000; } var array = new int[length]; var points = new[] { 4, 2, 3 }; fixed(int *dest = array) { MemoryOperations.Fill(dest, 42, length); } Console.WriteLine($"Voilà super rapide les {length} éléments ptdr *transition Leclerc*"); var smallerLength = length / 4; var array2 = new int[smallerLength]; var array3 = new int[smallerLength]; var timeStamp = CStopwatch.GetTimestamp(); Console.WriteLine($"Test: {smallerLength} elements"); // no pointer for (int i = 0; i < smallerLength; i++) { array2[i] = i + i * i; } Console.WriteLine($"Completed with no pointers in {CStopwatch.GetTimestamp() - timeStamp} units"); timeStamp = CStopwatch.GetTimestamp(); fixed(int *array3P = array3) { for (int i = 0; i < smallerLength; i++) { *(array3P + i) = i + i * i; } } Console.WriteLine($"Completed with a pointy pointer in {CStopwatch.GetTimestamp() - timeStamp} units"); }
public bool Authenticate( ReadOnlySpan <byte> clientPublicKey, ReadOnlySpan <byte> clientProof) { _A = BigIntFromByteArray(clientPublicKey.ToArray()); _M1 = BigIntFromByteArray(clientProof.ToArray()); if (_A.IsZero || (_A % _N).IsZero) { return(false); } var u = BigIntFromByteArray(HashArrays( BigIntToByteArray(_A), BigIntToByteArray(_B) )); var S = BigInteger.ModPow( _A * BigInteger.ModPow(_v, u, _N), _b, _N); _K = ComputeSessionKey(S); Span <byte> ngHash = HashArrays(BigIntToByteArray(_N)); ReadOnlySpan <byte> gHash = HashArrays(BigIntToByteArray(_g)); MemoryOperations.InPlaceXor(ngHash, gHash); var iHash = HashArrays(Encoding.UTF8.GetBytes(_I)); var clientProofCheck = HashArrays( ngHash.ToArray(), iHash, BigIntToByteArray(_s), BigIntToByteArray(_A), BigIntToByteArray(_B), BigIntToByteArray(_K) ); return(clientProof.SequenceEqual(clientProofCheck)); }
/// <summary> /// Writes a sample to the buffer. /// </summary> /// <param name="sample">A pointer to the first byte of the sample write.</param> /// <param name="index">The index of the target sample to overwrite.</param> public unsafe void Write(byte *sample, int index) { if (mode == OperationMode.DirectCopy) { int sampleStart = index * target.Format.Size; fixed(byte *destPtr = target.RawData) { MemoryOperations.Copy(destPtr + sampleStart, sample, target.Format.Size); } } else { // Read the sample to the buffer for (int j = 0; j < writeFormat.Size; j++) { buffer[j] = sample[j]; } // Pass 1: Upmix/downmix channels if (writeFormat.Channels < target.Format.Channels) { UpmixChannels( buffer, writeFormat.Channels, target.Format.Channels, writeFormat ); } fixed(byte *bufferPtr = buffer, destPtr = target.RawData) { // Pass 2: Change the bit-depth if (writeFormat.BitDepth != target.Format.BitDepth) { ChangeBitDepth( bufferPtr, target.Format.Channels, writeFormat.BitDepth, target.Format.BitDepth ); } // Pass 3: Change the sign if (shouldChangeSign) { if (shouldMakeSigned) { MakeSigned(bufferPtr, target.Format); } else { MakeUnsigned(bufferPtr, target.Format); } } int sampleStart = index * target.Format.Size; MemoryOperations.Copy(destPtr + sampleStart, bufferPtr, target.Format.Size); } } }
/// <summary> /// Converts the specified samples to the specified target format. /// The specified buffer pointer must be large enough to hold both /// the input samples, and the converted output samples. /// </summary> protected static unsafe void ChangeBitDepth(byte *bufferPtr, byte channels, AudioBitDepth inputBitDepth, AudioBitDepth outputBitDepth) { // Convert the bit-depth // We have to re-normalize the samples; from the source data type's min and max value, // to the target data type's min and max values - this operation can be represented by // the following formula: // (value / max source data type value) * max target data type value // For example, to convert a 16-bit sample 0x0E to a 32-bit sample: // (14 / 32767) * 2147483647 // However, this approach, while the most obvious from a mathematical standpoint, // uses floating-point math. This can be much slower than direct bit-manipulation. // The code below will do the equivalent to the provided formula by using // bit-manipulation operators, making the method much more performant. // // By using bit-shifting, we do not have to change the sign of the samples // which is useful for us as we convert the samples in several different passes. switch (inputBitDepth) { case AudioBitDepth.Bits8: { // 8 bit -> target bit depth byte[] samples = new byte[channels]; fixed(byte *samplesPtr = samples) { MemoryOperations.Copy(samplesPtr, bufferPtr, channels); ChangeBitDepth(bufferPtr, outputBitDepth, channels, samplesPtr); } break; } case AudioBitDepth.Bits16: { // 16 bit -> target bit depth short[] samples = new short[channels]; fixed(short *samplesPtr = samples) { MemoryOperations.Copy((byte *)samplesPtr, bufferPtr, channels * sizeof(short)); ChangeBitDepth(bufferPtr, outputBitDepth, channels, samplesPtr); } break; } case AudioBitDepth.Bits24: { // 24 bit -> target bit depth int[] samples = new int[channels]; for (int j = 0; j < channels; j++) { samples[j] = ToInt24(bufferPtr, j * 3); } fixed(int *samplesPtr = samples) { ChangeBitDepth24(bufferPtr, outputBitDepth, channels, samplesPtr); } break; } case AudioBitDepth.Bits32: { // 32 bit -> target bit depth int[] samples = new int[channels]; fixed(int *samplesPtr = samples) { MemoryOperations.Copy((byte *)samplesPtr, bufferPtr, channels * sizeof(int)); ChangeBitDepth(bufferPtr, outputBitDepth, channels, samplesPtr); } break; } } }
static unsafe void *InternalInvoke(void *maddr, int pcnt, void **parameters, void **types, void *ret_vtbl, uint flags) { /* Modify the types array to contain the call locations of each parameter * * 0 - INTEGER (pass as-is) * 1 - INTEGER (unbox in asm) * 2 - SSE (unbox in asm) * 3 - MEMORY (upper 24 bits give length of object) * 4 - INTEGER (unbox low 32 bits in asm) * 5 - INTEGER (unbox to byref in asm) */ for (int i = 0; i < pcnt; i++) { // handle this pointer if (i == 0 && ((flags & TysosMethod.invoke_flag_instance) != 0)) { if ((flags & TysosMethod.invoke_flag_vt) != 0) { // we need to unbox the this pointer to a managed pointer types[i] = (void *)5; } else { types[i] = (void *)0; } } else { // the type we need is encoded in the vtable var vtbl = types[i]; var cur_class = *((byte *)vtbl + 0x1 + ClassOperations.GetVtblTargetFieldsOffset()); types[i] = (void *)cur_class; } } var ret = asm_invoke(maddr, pcnt, parameters, types); // See if we have to box the return type if (ret_vtbl != null && ((flags & TysosMethod.invoke_flag_vt_ret) != 0)) { // Get the size of the return type var tsize = *(int *)((byte *)ret_vtbl + ClassOperations.GetVtblTypeSizeOffset()) - ClassOperations.GetBoxedTypeDataOffset(); /* TODO: handle VTypes that don't fit in a register */ if (tsize > 8) { throw new NotImplementedException("InternalInvoke: return type not supported (size " + tsize.ToString() + ")"); } // Build a new boxed version of the type var obj = (void **)MemoryOperations.GcMalloc(tsize + ClassOperations.GetBoxedTypeDataOffset()); * obj = ret_vtbl; *(int *)((byte *)obj + ClassOperations.GetMutexLockOffset()) = 0; System.Diagnostics.Debugger.Log(0, "libsupcs", "x86_64_invoke: returning boxed type of size " + tsize.ToString()); if (tsize > 4) { *(long *)((byte *)obj + ClassOperations.GetBoxedTypeDataOffset()) = (long)ret; } else { *(int *)((byte *)obj + ClassOperations.GetBoxedTypeDataOffset()) = (int)((long)ret & 0xffffffff); } return(obj); } else if (ret_vtbl == null) { System.Diagnostics.Debugger.Log(0, "libsupcs", "x86_64_invoke: returning void"); return(ret); } else { System.Diagnostics.Debugger.Log(0, "libsupcs", "x86_64_invoke: returning object"); return(ret); } }