public static PyUnicodeObject33 Create(DkmProcess process, string value)
{
var allocator = process.GetDataItem <PyObjectAllocator>();
Debug.Assert(allocator != null);
var result = allocator.Allocate <PyUnicodeObject33>(value.Length * sizeof(char));
result._asciiObject.hash.Write(-1);
result._asciiObject.length.Write(value.Length);
result._compactObject.wstr_length.Write(value.Length);
var state = new State {
interned = Interned.SSTATE_NOT_INTERNED,
kind = PyUnicode_Kind.PyUnicode_2BYTE_KIND,
compact = true,
ascii = false,
ready = true
};
result._asciiObject.state.Write((byte)state);
ulong dataPtr = result.Address.OffsetBy(StructProxy.SizeOf <PyCompactUnicodeObject>(process));
result._asciiObject.wstr.Write(dataPtr);
process.WriteMemory(dataPtr, Encoding.Unicode.GetBytes(value));
return(result);
}
public PyCodeObject_FieldOffsets(DkmProcess process)
{
PyCodeObject.Fields fields = StructProxy.GetStructFields <PyCodeObject, PyCodeObject.Fields>(process);
co_varnames = fields.co_varnames.Offset;
co_filename = fields.co_filename.Offset;
co_name = fields.co_name.Offset;
}
public PyUnicodeObject27_FieldOffsets(DkmProcess process)
{
var fields = StructProxy.GetStructFields <PyUnicodeObject27, PyUnicodeObject27.Fields>(process);
length = fields.length.Offset;
str = fields.str.Offset;
}
public StructProxyBenchmarks()
{
_defaultRunner = new Runner <IDataProvider <Event> >(new Impl());
var impl = StructProxy.CreateProxyInstance <IDataProvider <Event> >(new Impl());
_generatedRunner = (IRunner)Activator.CreateInstance(typeof(Runner <>).MakeGenericType(impl.GetType()), impl);
}
public void ShouldNotFailForPublicTypeWithInternalGenericArgument()
{
var bar = new Bar <InternalBarArg>();
var barProxy = StructProxy.CreateProxyInstance <IBar <InternalBarArg> >(bar);
Assert.IsNotNull(barProxy);
Assert.AreEqual(barProxy, bar);
}
public PyFrameObject_FieldOffsets(DkmProcess process)
{
var fields = StructProxy.GetStructFields <PyFrameObject, PyFrameObject.Fields>(process);
f_code = fields.f_code.Offset;
f_globals = fields.f_globals.Offset;
f_locals = fields.f_locals.Offset;
f_lineno = fields.f_lineno.Offset;
}
/// <summary>
/// Create a new <see cref="ProcessingSequenceBarrier{TSequencer,TWaitStrategy}"/> with dedicated generic arguments.
/// </summary>
public static ISequenceBarrier Create(ISequencer sequencer, IWaitStrategy waitStrategy, Sequence cursorSequence, ISequence[] dependentSequences)
{
var sequencerProxy = StructProxy.CreateProxyInstance(sequencer);
var waitStrategyProxy = StructProxy.CreateProxyInstance(waitStrategy);
var sequencerBarrierType = typeof(ProcessingSequenceBarrier <,>).MakeGenericType(sequencerProxy.GetType(), waitStrategyProxy.GetType());
return((ISequenceBarrier)Activator.CreateInstance(sequencerBarrierType, sequencerProxy, waitStrategyProxy, cursorSequence, dependentSequences));
}
public void ShouldNotFailForInternalType()
{
var foo = new InternalFoo();
IFoo fooProxy = null;
Assert.DoesNotThrow(() => fooProxy = StructProxy.CreateProxyInstance <IFoo>(foo));
Assert.IsNotNull(fooProxy);
Assert.AreEqual(fooProxy, foo);
}
public void ShouldNotFailForInternalType()
{
var foo = new InternalFoo();
var fooProxy = StructProxy.CreateProxyInstance <IFoo>(foo);
Assert.DoesNotThrow(() => fooProxy.Value = 1);
Assert.DoesNotThrow(() => fooProxy.Compute(1, 2));
Assert.IsNotNull(fooProxy);
Assert.AreSame(fooProxy, foo);
}
public void ShouldNotFailForExplicitImplementation()
{
var foo = new ExplicitImplementation();
var fooProxy = StructProxy.CreateProxyInstance <IFoo>(foo);
Assert.DoesNotThrow(() => fooProxy.Value = 1);
Assert.DoesNotThrow(() => fooProxy.Compute(1, 2));
Assert.IsNotNull(fooProxy);
Assert.AreSame(fooProxy, foo);
}
/// <summary>
/// Create a new <see cref="IEventProcessor{T}"/> with dedicated generic arguments.
/// </summary>
/// <typeparam name="T">the type of event used.</typeparam>
/// <param name="dataProvider">dataProvider to which events are published</param>
/// <param name="sequenceBarrier">SequenceBarrier on which it is waiting.</param>
/// <param name="eventHandler">eventHandler is the delegate to which events are dispatched.</param>
/// <returns></returns>
public static IAsyncEventProcessor <T> Create <T>(IDataProvider <T> dataProvider, AsyncSequenceBarrier sequenceBarrier, IAsyncBatchEventHandler <T> eventHandler)
where T : class
{
var dataProviderProxy = StructProxy.CreateProxyInstance(dataProvider);
var sequencerOptions = sequenceBarrier.GetSequencerOptions();
var eventHandlerProxy = StructProxy.CreateProxyInstance(eventHandler);
var eventProcessorType = typeof(AsyncBatchEventProcessor <, , ,>).MakeGenericType(typeof(T), dataProviderProxy.GetType(), sequencerOptions.GetType(), eventHandlerProxy.GetType());
return((IAsyncEventProcessor <T>)Activator.CreateInstance(eventProcessorType, dataProviderProxy, sequenceBarrier, eventHandlerProxy) !);
}
internal static IEventProcessor <T> Create <T>(IDataProvider <T> dataProvider, SequenceBarrier sequenceBarrier, IBatchEventHandler <T> eventHandler, Type processorType)
where T : class
{
var dataProviderProxy = StructProxy.CreateProxyInstance(dataProvider);
var sequencerOptions = sequenceBarrier.GetSequencerOptions();
var eventHandlerProxy = StructProxy.CreateProxyInstance(eventHandler);
var eventProcessorType = processorType.MakeGenericType(typeof(T), dataProviderProxy.GetType(), sequencerOptions.GetType(), eventHandlerProxy.GetType());
return((IEventProcessor <T>)Activator.CreateInstance(eventProcessorType, dataProviderProxy, sequenceBarrier, eventHandlerProxy) !);
}
internal static IValueBatchEventProcessor <T> Create <T>(IValueDataProvider <T> dataProvider, ISequenceBarrier sequenceBarrier, IValueEventHandler <T> eventHandler, Type processorType)
where T : struct
{
var dataProviderProxy = StructProxy.CreateProxyInstance(dataProvider);
var sequenceBarrierProxy = StructProxy.CreateProxyInstance(sequenceBarrier);
var eventHandlerProxy = StructProxy.CreateProxyInstance(eventHandler);
var batchStartAwareProxy = CreateBatchStartAwareProxy(eventHandler);
var batchEventProcessorType = processorType.MakeGenericType(typeof(T), dataProviderProxy.GetType(), sequenceBarrierProxy.GetType(), eventHandlerProxy.GetType(), batchStartAwareProxy.GetType());
return((IValueBatchEventProcessor <T>)Activator.CreateInstance(batchEventProcessorType, dataProviderProxy, sequenceBarrierProxy, eventHandlerProxy, batchStartAwareProxy));
}
private static IBatchStartAware CreateBatchStartAwareProxy(object eventHandler)
{
if (!(eventHandler is IBatchStartAware batchStartAware))
{
return(new NoopBatchStartAware());
}
var proxy = StructProxy.CreateProxyInstance(batchStartAware);
var proxyGenerationFailed = ReferenceEquals(proxy, batchStartAware);
return(proxyGenerationFailed ? new DefaultBatchStartAware(batchStartAware) : proxy);
}
internal static IValueEventProcessor <T> Create <T>(IValueDataProvider <T> dataProvider, SequenceBarrier sequenceBarrier, IValueEventHandler <T> eventHandler, Type processorType)
where T : struct
{
var dataProviderProxy = StructProxy.CreateProxyInstance(dataProvider);
var sequencerOptions = sequenceBarrier.GetSequencerOptions();
var eventHandlerProxy = StructProxy.CreateProxyInstance(eventHandler);
var onBatchStartInvoker = CreateOnBatchStartEvaluator(eventHandler);
var eventProcessorType = processorType.MakeGenericType(typeof(T), dataProviderProxy.GetType(), sequencerOptions.GetType(), eventHandlerProxy.GetType(), onBatchStartInvoker.GetType());
return((IValueEventProcessor <T>)Activator.CreateInstance(eventProcessorType, dataProviderProxy, sequenceBarrier, eventHandlerProxy, onBatchStartInvoker) !);
}
/// <summary>
/// Create a new <see cref="IBatchEventProcessor{T}"/> with dedicated generic arguments.
/// </summary>
/// <typeparam name="T">the type of event used.</typeparam>
/// <param name="dataProvider">dataProvider to which events are published</param>
/// <param name="sequenceBarrier">SequenceBarrier on which it is waiting.</param>
/// <param name="eventHandler">eventHandler is the delegate to which events are dispatched.</param>
/// <returns></returns>
public static IBatchEventProcessor <T> Create <T>(IDataProvider <T> dataProvider, ISequenceBarrier sequenceBarrier, IEventHandler <T> eventHandler)
where T : class
{
var dataProviderProxy = StructProxy.CreateProxyInstance(dataProvider);
var sequenceBarrierProxy = StructProxy.CreateProxyInstance(sequenceBarrier);
var eventHandlerProxy = StructProxy.CreateProxyInstance(eventHandler);
var batchStartAwareProxy = eventHandler is IBatchStartAware batchStartAware?StructProxy.CreateProxyInstance(batchStartAware) : new NoopBatchStartAware();
var batchEventProcessorType = typeof(BatchEventProcessor <, , , ,>).MakeGenericType(typeof(T), dataProviderProxy.GetType(), sequenceBarrierProxy.GetType(), eventHandlerProxy.GetType(), batchStartAwareProxy.GetType());
return((IBatchEventProcessor <T>)Activator.CreateInstance(batchEventProcessorType, dataProviderProxy, sequenceBarrierProxy, eventHandlerProxy, batchStartAwareProxy));
}
public TObject Allocate <TObject>(long extraBytes = 0)
where TObject : PyObject
{
ulong ptr = Allocate(StructProxy.SizeOf <TObject>(_process) + extraBytes);
var obj = DataProxy.Create <TObject>(_process, ptr, polymorphic: false);
obj.ob_refcnt.Write(1);
var pyType = PyObject.GetPyType <TObject>(_process);
obj.ob_type.Write(pyType);
return(obj);
}
public static void Test()
{
IEventHandler <LongEvent> target = new LongEventHandler();
var eventHandlerProxy = StructProxy.CreateProxyInstance(target);
var eventHandlerProxy2 = StructProxy.CreateProxyInstance(target);
eventHandlerProxy.OnEvent(new LongEvent()
{
Value = 123
}, 12, true);
eventHandlerProxy2.OnEvent(new LongEvent()
{
Value = 123
}, 12, true);
}
public PyUnicodeObject33_FieldOffsets(DkmProcess process)
{
sizeof_PyASCIIObject = StructProxy.SizeOf <PyASCIIObject>(process);
sizeof_PyCompactUnicodeObject = StructProxy.SizeOf <PyUnicodeObject33>(process);
PyASCIIObject.Fields asciiFields = StructProxy.GetStructFields <PyASCIIObject, PyASCIIObject.Fields>(process);
length = asciiFields.length.Offset;
state = asciiFields.state.Offset;
wstr = asciiFields.wstr.Offset;
PyCompactUnicodeObject.Fields compactFields = StructProxy.GetStructFields <PyCompactUnicodeObject, PyCompactUnicodeObject.Fields>(process);
wstr_length = compactFields.wstr_length.Offset;
PyUnicodeObject33.Fields unicodeFields = StructProxy.GetStructFields <PyUnicodeObject33, PyUnicodeObject33.Fields>(process);
data = unicodeFields.data.Offset;
}
public BatchEventProcessorBenchmarks()
{
var ringBuffer = new RingBuffer <XEvent>(() => new XEvent(), new SingleProducerSequencer(4096, new SpinWaitWaitStrategy()));
var eventHandler = new XEventHandler();
var sequenceBarrier = ringBuffer.NewBarrier();
ringBuffer.PublishEvent().Dispose();
var dataProviderProxy = StructProxy.CreateProxyInstance <IDataProvider <XEvent> >(ringBuffer);
var sequenceBarrierProxy = StructProxy.CreateProxyInstance(sequenceBarrier);
var eventHandlerProxy = StructProxy.CreateProxyInstance <IEventHandler <XEvent> >(eventHandler);
var batchStartAwareProxy = new NoopBatchStartAware();
var runnerType = typeof(Runner <, , , ,>).MakeGenericType(typeof(XEvent), dataProviderProxy.GetType(), sequenceBarrierProxy.GetType(), eventHandlerProxy.GetType(), batchStartAwareProxy.GetType());
_runner = (IRunner)Activator.CreateInstance(runnerType, dataProviderProxy, sequenceBarrierProxy, eventHandlerProxy, batchStartAwareProxy);
}
public EventProcessorBenchmarks_Wait()
{
var waitStrategy = new YieldingWaitStrategy();
var sequencer = new SingleProducerSequencer(64, waitStrategy);
var cursorSequence = new Sequence();
var dependentSequences = new ISequence[0];
var sequenceBarrier = new SequenceBarrier(sequencer, waitStrategy, cursorSequence, dependentSequences);
var sequenceBarrierClass = new SequenceBarrierClass(sequencer, waitStrategy, cursorSequence, dependentSequences);
var sequenceBarrierProxy = StructProxy.CreateProxyInstance(sequenceBarrierClass);
var eventProcessorType = typeof(PartialEventProcessor <,>).MakeGenericType(typeof(ISequenceBarrierOptions.IsDependentSequencePublished), sequenceBarrierProxy.GetType());
_processor1 = (IPartialEventProcessor)Activator.CreateInstance(eventProcessorType, sequenceBarrier, sequenceBarrierProxy);
_processor2 = new PartialEventProcessor <ISequenceBarrierOptions.IsDependentSequencePublished, SequenceBarrierStruct>(sequenceBarrier, new SequenceBarrierStruct(sequencer, waitStrategy, cursorSequence, dependentSequences));
sequencer.Publish(42);
cursorSequence.SetValue(42);
}
public void ShouldGenerateProxyForType()
{
var foo = new Foo();
var fooProxy = StructProxy.CreateProxyInstance <IFoo>(foo);
Assert.IsNotNull(fooProxy);
Assert.IsTrue(fooProxy.GetType().IsValueType);
Assert.IsInstanceOf <IFoo>(fooProxy);
Assert.IsInstanceOf <IOtherInterface>(fooProxy);
fooProxy.Value = 888;
Assert.AreEqual(foo.Value, 888);
Assert.AreEqual(fooProxy.Value, 888);
fooProxy.Compute(400, 44);
Assert.AreEqual(foo.Value, 444);
Assert.AreEqual(fooProxy.Value, 444);
}
public PyFrameObject_FieldOffsets(DkmProcess process)
{
if (process.GetPythonRuntimeInfo().LanguageVersion <= PythonLanguageVersion.V35)
{
var fields = StructProxy.GetStructFields <PyFrameObject, PyFrameObject.Fields_27_35>(process);
f_back = -1;
f_code = fields.f_code.Offset;
f_globals = fields.f_globals.Offset;
f_locals = fields.f_locals.Offset;
f_lineno = fields.f_lineno.Offset;
}
else
{
var fields = StructProxy.GetStructFields <PyFrameObject, PyFrameObject.Fields_36>(process);
f_back = fields.f_back.Offset;
f_code = fields.f_code.Offset;
f_globals = fields.f_globals.Offset;
f_locals = fields.f_locals.Offset;
f_lineno = fields.f_lineno.Offset;
}
}
public static PyUnicodeObject27 Create(DkmProcess process, string value)
{
// Allocate string buffer together with the object itself in a single block.
var allocator = process.GetDataItem <PyObjectAllocator>();
Debug.Assert(allocator != null);
var result = allocator.Allocate <PyUnicodeObject27>(value.Length * 2);
result.length.Write(value.Length);
var str = result.Address.OffsetBy(StructProxy.SizeOf <PyUnicodeObject27>(process));
result.str.Raw.Write(str);
var buf = Encoding.Unicode.GetBytes(value);
process.WriteMemory(str, buf);
return(result);
}
public PyVarObject_FieldOffsets(DkmProcess process)
{
var fields = StructProxy.GetStructFields <PyVarObject, PyVarObject.PyVarObject_Fields>(process);
ob_size = fields.ob_size.Offset;
}
public PyBytesObject_FieldOffsets(DkmProcess process)
{
var fields = StructProxy.GetStructFields <PyBytesObject, PyBytesObject.Fields>(process);
ob_sval = fields.ob_sval.Offset;
}
public PyObject_FieldOffsets(DkmProcess process)
{
PyObject.PyObject_Fields fields = StructProxy.GetStructFields <PyObject, PyObject.PyObject_Fields>(process);
ob_type = fields.ob_type.Offset;
}
public override string ToString()
{
byte[] buf;
State state = (State)_asciiObject.state.Read();
if (state.ascii)
{
state.kind = PyUnicode_Kind.PyUnicode_1BYTE_KIND;
}
if (!state.ready)
{
ulong wstr = _asciiObject.wstr.Read();
if (wstr == 0)
{
return(null);
}
uint wstr_length = checked ((uint)_compactObject.wstr_length.Read());
if (wstr_length == 0)
{
return("");
}
buf = new byte[wstr_length * 2];
Process.ReadMemory(wstr, DkmReadMemoryFlags.None, buf);
return(Encoding.Unicode.GetString(buf, 0, buf.Length));
}
int length = checked ((int)_asciiObject.length.Read());
if (length == 0)
{
return("");
}
ulong data;
if (!state.compact)
{
data = GetFieldProxy(_fields.data).Read();
}
else if (state.ascii)
{
data = Address.OffsetBy(StructProxy.SizeOf <PyASCIIObject>(Process));
}
else
{
data = Address.OffsetBy(StructProxy.SizeOf <PyCompactUnicodeObject>(Process));
}
if (data == 0)
{
return(null);
}
buf = new byte[length * (int)state.kind];
Process.ReadMemory(data, DkmReadMemoryFlags.None, buf);
Encoding enc;
switch (state.kind)
{
case PyUnicode_Kind.PyUnicode_1BYTE_KIND:
enc = _latin1;
break;
case PyUnicode_Kind.PyUnicode_2BYTE_KIND:
enc = Encoding.Unicode;
break;
case PyUnicode_Kind.PyUnicode_4BYTE_KIND:
enc = Encoding.UTF32;
break;
default:
Debug.Fail("Unsupported PyUnicode_Kind " + state.kind);
return(null);
}
return(enc.GetString(buf, 0, buf.Length));
}
