This project is read-only.
= Version 1.0 "Weisbecker" =
  • Secure VirtualMachine class so that any internal classes cannot be accessed outside the class such is vulnerable memory, and mounted files.
  • Restrict how debuggers can be used and they need to authenticate with a token so debuggers are not exploitable when developer chooses not to allow them in public releases
  • Improve memory management such as paging and faster read/write with support of page/pointer descriptors for analysis of mapped memory state and usage
  • Implement memory access caching where the memory doesn't does not always need to constantly look-up pages for every memory read/write operation. The simple one page reference caching still checks addresses per byte operation. A thread should run in the background and check the current address pointer and cache more memory (or update) before the address pointer hits the end of the cache block. This allows the whole virtual machine to run without any performance hits since memory is not consistent on how memory pages of data are stored. This method converts non-consecutive memory into temporarily consecutive memory without even doubling the memory usage of the class itself.
  • Implement some experimental vector structures that to allow .NET programs access real vector accelerated operations. If native CPU host supports vector processing, the class will wrap native code and use it. If there is not HW support for using vectors then it will have to be emulated for compatibility reasons or it can try to approach the GPU to perform vector math. This also includes support of overriding the class and implementing vector functionality in other ways such if this was running on a PowerPC and not just x86. (NEmu.Vector assembly) Mono.Simd might already be all we need for vectorization, howerver will need to test on how well it works especially not running on Mono framework / VM. We do not know if the Mono natively implements Simd into its CLR, if it does, then we have to either use Mono for the whole framework or wrapper class that either runs native on Mono CLR or runs our own DLL based vectorization at least for Windows platforms.
  • VirtualMachine class needs a way to allow internal access only to classes that have references inside of it, such as memory pages might need to get access to internal parts of the machine. It will be tricky to do this properly without risking anything to really needing to be visibly public.  We need a internal VM communication system like linux’s Dbus daemon process.
  • Plans to implement a library WPF level of classes for associating WPF controls with the core Nemu library properly. (NEmu.UIToolkits.Presentation)
  • Also maybe make a clone of the controls in WinForms (NEmu.UIToolkits.WinForms) for native win32 GUI, it will be some ugly coding since it doesn’t support advanced graphics and effects on the GDI+ end.
  • If anytime, maybe do WxWidgets for cross-platform GUI (NEmu.UIToolkits.WxWidgets) or might do Qt (Nemu.UIToolkits.Qt)
  • Support for Max OS X native GUI via Cocoa (NEmu.UIToolkits.Cocoa)
  • More support on Dynamic recompilation for emulators, such as base classes and tools. Allow memory to directly work in dynarec time such as using pointers in emitted code without needing to call read/write methods. More research to be done for what else a dyanrec needs.
  • Android Port of the whole framework using Mono Android.  Need a developer who has the Mono Android SDK on them for testing and development.

Last edited Oct 15, 2011 at 1:05 AM by bryanperris, version 6


No comments yet.