| Sıra | DOSYA ADI | Format | Bağlantı |
|---|---|---|---|
| 01. | Static Innovations Monos Innovations | pptx | Sunumu İndir |
Transkript
Mono And .NET Miguel de IcazaVP Developer PlatformNovell, Inc.PC54
Introduction to Mono Mono’s Customizable CLR Mono’s C# Eval Assembly binary reshaping Turbo charging games and graphics Static Compilation OthersAgenda
An open source .NET implementation: A subset of .NET Sponsored by Novell ~120 non-affiliated contributors (1.2 -> 2.0) Direction driven by contributorsMono 2.0Just released!
Our goal is to have a compatible runtime to the CLR ECMA specifications make it possible Develop, build, debug on Visual Studio or Unix Deploy on Linux, Mac OSX and embeddedCompatibility
APIsMono.RelaxNG. lJava/IKVMJ IMono.ZeroConf. r f Mono.Nat. tMono.Cecil. ilNovell.Ldapll.ASP.NET.Apache and FastCGI st ISystem.DataSQL Servert . t r rServerInfrastructureIMono.Fuse.Mono.Addins. iPostgress, MySQLSqlite, Oracle, Sybasest r ss, Llit , r cl , sTao.Framework. r rC5NDesk.DBus.Third Partyi Gecko# (Mozilla) ( ill )Mono.Nat. tMono.Torrent. rr t Mono.Upnp.Gtk#t Windows.Formsi . rCocoa#ClientliMono.Cairo. irGdk#Pango#
We can offer a few bonuses Take .NET where no .NET has gone before Offering new forward-compatible features Support special scenariosMono's CLI Implementation
We can offer a few bonuses Take .NET where no .NET has gone before Offering new forward-compatible features Support special scenariosMono's CLI Implementation
Microsoft has the CLR, CF and the CoreCLR CoreCLR is a small version of CLR CoreCLR used in Mesh and Silverlight Compact Framework used in XNACLRs For Everyone
Microsoft has the CLR, CF and the CoreCLR CoreCLR is a small version of CLR CoreCLR used in Mesh and Silverlight Compact Framework used in XNA For everyone else, there is MonoCLRs For Everyone
Full framework is 100 megs (uncompressed) Minimal setup is 2 megs (uncompressed) Modular runtime can be shrunk/grown:Mono AdaptabilityFrom full framework to tailored framework
The Evolution of a Compiler (or, C# 5 today)
C# compiler written in C# Originally, a project to learn to write C# codeMono's C# 3.0 Compiler
C# compiler written in C# Originally, a project to learn to write C# code First bootstrap (2001) 17 seconds to bootstrap, 10,000 lines csc compiled it in a secondMono's C# 3.0 Compiler
C# compiler written in C# Originally, a project to learn to write C# code First bootstrap (2001) 17 seconds to bootstrap 10,000 lines csc compiled it in a second Speed is no longer a problem Today 82,000 lines in 2.2 seconds 1.6x slower than cscMono's C# 3.0 Compiler
Mono.CSharp.Evaluator Encapsulates the compiler in one class Provides C# Eval and C# Run:Mono.CSharp.dll – Compiler Serviceusing System;using Mono.CSharp;class MyFirstCSharpInterpreter { static void Main (string [] args) { object r = Evaluator.Evaluate (args [0]); Console.WriteLine (r); }}
Read-Eval-Print-Loop (repl) Script applications with C# Rapid prototyping in target language Automation Would be cool to have this on every app!Mono.CSharp – Applications
Python and Ruby have interactive shells Read-Eval-Print Loop Expressions and Statements:The csharp Commandcsharp> 1;1;csharp> “Hello, World”.IndexOf (“,”);5;csharp> 1 + > 2;3csharp> var a = Console.ReadLine ();
LINQ From The Command Line$ csharpMono C# Shell, type “help;” for helpEnter statements below.csharp> using System.IO;csharp> var last_week = DateTime.Now – TimeSpan.FromDays (7);csharp> from f in Directory.GetFiles (“/etc”) > let fi = new FileInfo (f) > where fi.LastWriteTime < last_week > select f;{ “/etc/adjtime”, “/etc/asound.state”, “/etc/ld.so.cache”, “/etc/mtab”, “/etc/printcap”, “/etc/resolv.conf” }csharp>
Interactive LINQ To XML csharp> LoadLibrary (“System.Xml.Linq”);csharp> using System.Xml.Linq;csharp> var xml = new XElement(\CompilerSources\, > from f in Directory.GetFiles (\/cvs/mcs/mcs\) > let fi = new FileInfo (f) > orderby fi.Length > select new XElement (\file\, > new XAttribute (\name\, f), > new XAttribute (\size\, fi.Length)));csharp> xml;<CompilerSources> <file name=\/cvs/mcs/mcs/mcs.exe.config\ size=\395\ /> <file name=\/cvs/mcs/mcs/gmcs.exe.config\ size=\464\ /> <file name=\/cvs/mcs/mcs/OPTIMIZE\ size=\498\ /> <file name=\/cvs/mcs/mcs/lambda.todo\ size=\658\ /> [...]</CompilerSources>
GUI ShellC# eval hosted in a GUI Replace base class, with GUI base class:
Replace base class, with GUI base class:GUI ShellC# eval hosted in a GUI
Plot (Func<double,double>);GUI Shell, Quick Plot Method
Plot (Func<double,double>);GUI Shell, Quick Plot Method
CompleteC# Compilerl ilMono.CSharp. Everything publicr t i li Minimal APIi i l IReshaping The APITurning the compiler into a library
CompleteC# Compilerl ilMono Linker i Mono.CSharp. Everything publicr t i li Uses Mono.Cecil Reshapes code Desired API Removes or hides . il ir I r i Minimal APIi i l IReshaping The APIAvoid manual work, reusing Mono.Cecil and Mono.Linkerlink.xmlli . l
Shrinking Assemblies Shipping only what is required Simplify deployment Create your own Compact Framework What you need from the superset .NET 3.5 to Silverlight We reshape our assemblies. Minimal hand-editing/tuning.Mono Linker Use Cases
Great innovations are possible Build on an existing large ecosystem Instrument, expand, innovate Special code generationBeyond the CLR: Innovating On A Solid FoundationVirtual machines are fascinating
Great innovations are possible Build on an existing large ecosystem Instrument, expand, innovate Special code generation VM potential limited by vendor realities Provider scarcity Shipping dates Staffing Product Management Feature prioritizationBeyond the CLR: Innovating On A Solid FoundationVirtual machines are fascinating
On the root AppDomain, on a new threadInjecting Code Into A Live ProcessThe Mono.Attach.VirtualMachine API
Injecting GUI Interactive C#Consoles for everyone!
Turbocharging GamesFast, Productive, Safe.Pick all three.
Game Software Components.• Rendering• Shading• Scene• Animation• Geometry• GUIiii titIDisplayi l• Physics• Collision• Particles• Terrainilli iti liSimulationi l• World rules• Enemy AI• User control• Camera• Behaviorl l I t liGame Logic i• Audio• Input• NetworkingiI tt iSupport
The ProblemGames are real-time programs 30 to 60 frames per second (0.016 seconds)• User control• Network events l InputI• Scripted, slow• React to change• Update scenei , l AII• Render Graphics• Play audio il iUpdates
Problem: Scripting Is A BottleneckGaming's Achilles' Heel• Rendering• Shading• Scene• Animation• Geometry• GUIiii titIDisplayi l• Physics• Collision• Particles• Terrainilli iti liSimulationi l• World rules• Enemy AI• User control• Camera• Behaviorl l I t liGame Logic i• Audio• Input• NetworkingiI tt iSupportC/C++ C/C++ C/C++Scripti
Language ChoicesProductivityPerformanceAssembly LanguageC/C++Fully DynamicC#/JavaFastSlowDifficultEasy
Mono’s CLR is ideal for embeddingMono in Gaming TodayMoving from scripting to static/compiled
Mono’s CLR is ideal for embedding Some examples SecondLife: Switched from LSL to Mono 50x to 300x performance increaseMono in Gaming TodayMoving from scripting to static/compiled
Mono’s CLR is ideal for embedding Some examples SecondLife: Switched from LSL to Mono 50x to 300x performance increase Unity3D: Powers Cartoon Network’s FusionFall Uses C#, UnityScript and Boo UnityScript is a strongly typed JavascriptMono in Gaming TodayMoving from scripting to static/compiled
Demo
Graphics Enginei iGame Engines iGame AI ITraditionalr iti lManaged Code In GamingImproving developer productivity while maintaining program speedScriptedSlow/easyCompiledFast/HardCompiledFast/Hard
Graphics Enginei iGame Engines iGame AI ITraditionalr iti l ImprovedI rManaged Code In GamingImproving developer productivity while maintaining program speedScriptedSlow/easyCompiledFast/HardCompiledFast/HardManagedFast/EasyCompiledFast/HardCompiledFast/Hard
Graphics Enginei iGame Engines iGame AI ITraditionalr iti l ImprovedI r Futuret rManaged Code In GamingImproving developer productivity while maintaining program speedScriptedSlow/easyCompiledFast/HardCompiledFast/HardManagedFast/EasyCompiledFast/HardCompiledFast/HardManagedFast/EasyManagedFast/EasyCompiledFast/Hard
Exploring an innocent looking loop in C#:3D Floating Point Vector OperationsAt the core of gaming enginesUpdatePos (Vector3f [] points, ref Vector3f delta){ for (int i = 0; i < points.Length; i++) points [i] += delta;}xiyizi+δxδyδzxi+δxyi+δyzi+δz=Vector3f static operator + (Vector3f a, Vector3f b){ return new Vector3f (a.x+b.x, a.y+b.y, a.z+b.z);}
UpdatePos Method In ILThe code that does the addition.method private static hidebysig default void UpdatePos (valuetype [Mono.Simd]Mono.Simd.Vector4f[] points, valuetype [Mono.Simd]Mono.Simd.Vector4f& delta) cil managed { // Method begins at RVA 0x2144// Code size 50 (0x32).maxstack 4.locals init (int32 V_0)IL_0000: ldc.i4.0 IL_0001: stloc.0 IL_0002: br IL_0028IL_0007: ldarg.0 IL_0008: ldloc.0 IL_0009: ldelema [Mono.Simd]Mono.Simd.Vector4fIL_000e: dup IL_000f: ldobj [Mono.Simd]Mono.Simd.Vector4fIL_0014: ldarg.1 IL_0015: ldobj [Mono.Simd]Mono.Simd.Vector4fIL_001a: call valuetype [Mono.Simd]Mono.Simd.Vector4f valuetype [Mono.Simd]Mono.Simd.Vector4f::op_Addition(valuetype [Mono.Simd]Mono.Simd.Vector4f, valuetype [Mono.Simd]Mono.Simd.Vector4f)IL_001f: stobj [Mono.Simd]Mono.Simd.Vector4fIL_0024: ldloc.0 IL_0025: ldc.i4.1 IL_0026: add IL_0027: stloc.0 IL_0028: ldloc.0 IL_0029: ldarg.0 IL_002a: ldlen IL_002b: conv.i4 IL_002c: blt IL_0007IL_0031: ret } // end of method X::UpdatePos
Vector4f.op_Addition in ILThe IL implementation // method line 24 .method public static hidebysig specialname default valuetype Mono.Simd.Vector4f op_Addition (valuetype Mono.Simd.Vector4f v1, valuetype Mono.Simd.Vector4f v2) cil managed { // Method begins at RVA 0x24ac // Code size 69 (0x45) .maxstack 7 .locals init ( valuetype Mono.Simd.Vector4f V_0) IL_0000: ldloca.s 0 IL_0002: ldarga.s 0 IL_0004: ldfld float32 Mono.Simd.Vector4f::x IL_0009: ldarga.s 1 IL_000b: ldfld float32 Mono.Simd.Vector4f::x IL_0010: add IL_0011: ldarga.s 0 IL_0013: ldfld float32 Mono.Simd.Vector4f::y IL_0018: ldarga.s 1 IL_001a: ldfld float32 Mono.Simd.Vector4f::y IL_001f: add IL_0020: ldarga.s 0 IL_0022: ldfld float32 Mono.Simd.Vector4f::z IL_0027: ldarga.s 1 IL_0029: ldfld float32 Mono.Simd.Vector4f::z IL_002e: add IL_002f: ldarga.s 0 IL_0031: ldfld float32 Mono.Simd.Vector4f::w IL_0036: ldarga.s 1 IL_0038: ldfld float32 Mono.Simd.Vector4f::w IL_003d: add IL_003e: call instance void valuetype Mono.Simd.Vector4f::'.ctor'(float32, float32, float32, float32) IL_0043: ldloc.0 IL_0044: ret } // end of method Vector4f::op_Addition
UpdatePos in x86 codeGenerated asssembly code00000000 <X_UpdatePos>: 69: 89 0c 24 mov %ecx,(%esp) 0: 55 push %ebp 6c: 8b 4d d8 mov -0x28(%ebp),%ecx 1: 8b ec mov %esp,%ebp 6f: 89 4c 24 04 mov %ecx,0x4(%esp) 3: 53 push %ebx 73: 8b 4d dc mov -0x24(%ebp),%ecx 4: 57 push %edi 76: 89 4c 24 08 mov %ecx,0x8(%esp) 5: 56 push %esi 7a: 8b 4d e0 mov -0x20(%ebp),%ecx 6: 83 ec 38 sub $0x38,%esp 7d: 89 4c 24 0c mov %ecx,0xc(%esp) 9: 8b 75 08 mov 0x8(%ebp),%esi 81: 83 ec 10 sub $0x10,%esp c: 8b 7d 0c mov 0xc(%ebp),%edi 84: 8b 4d c4 mov -0x3c(%ebp),%ecx f: 33 db xor %ebx,%ebx 87: 89 0c 24 mov %ecx,(%esp) 11: e9 ad 00 00 00 jmp c3 <X_UpdatePos+0xc3> 8a: 8b 4d c8 mov -0x38(%ebp),%ecx 16: 8b c0 mov %eax,%eax 8d: 89 4c 24 04 mov %ecx,0x4(%esp) 18: 39 5e 0c cmp %ebx,0xc(%esi) 91: 8b 4d cc mov -0x34(%ebp),%ecx 1b: 0f 86 b5 00 00 00 jbe d6 <X_UpdatePos+0xd6> 94: 89 4c 24 08 mov %ecx,0x8(%esp) 21: 8b cb mov %ebx,%ecx 98: 8b 4d d0 mov -0x30(%ebp),%ecx 23: c1 e1 04 shl $0x4,%ecx 9b: 89 4c 24 0c mov %ecx,0xc(%esp) 26: 8b c6 mov %esi,%eax 9f: 50 push %eax 28: 03 c1 add %ecx,%eax a0: e8 43 00 00 00 call op_Addition 2a: 05 10 00 00 00 add $0x10,%eax a5: 83 c4 20 add $0x20,%esp 2f: 89 45 bc mov %eax,-0x44(%ebp) a8: 8b 45 bc mov -0x44(%ebp),%eax 32: 8b 08 mov (%eax),%ecx ab: 8b 4d e4 mov -0x1c(%ebp),%ecx 34: 89 4d c4 mov %ecx,-0x3c(%ebp) ae: 89 08 mov %ecx,(%eax) 37: 8b 48 04 mov 0x4(%eax),%ecx b0: 8b 4d e8 mov -0x18(%ebp),%ecx 3a: 89 4d c8 mov %ecx,-0x38(%ebp) b3: 89 48 04 mov %ecx,0x4(%eax) 3d: 8b 48 08 mov 0x8(%eax),%ecx b6: 8b 4d ec mov -0x14(%ebp),%ecx 40: 89 4d cc mov %ecx,-0x34(%ebp) b9: 89 48 08 mov %ecx,0x8(%eax) 43: 8b 40 0c mov 0xc(%eax),%eax bc: 8b 4d f0 mov -0x10(%ebp),%ecx 46: 89 45 d0 mov %eax,-0x30(%ebp) bf: 89 48 0c mov %ecx,0xc(%eax) 49: 8b 07 mov (%edi),%eax c2: 43 inc %ebx 4b: 89 45 d4 mov %eax,-0x2c(%ebp) c3: 8b 46 0c mov 0xc(%esi),%eax 4e: 8b 47 04 mov 0x4(%edi),%eax c6: 3b d8 cmp %eax,%ebx 51: 89 45 d8 mov %eax,-0x28(%ebp) c8: 0f 8c 4a ff ff ff jl 18 <X_UpdatePos+0x18> 54: 8b 47 08 mov 0x8(%edi),%eax ce: 8d 65 f4 lea -0xc(%ebp),%esp 57: 89 45 dc mov %eax,-0x24(%ebp) d1: 5e pop %esi 5a: 8b 47 0c mov 0xc(%edi),%eax d2: 5f pop %edi 5d: 89 45 e0 mov %eax,-0x20(%ebp) d3: 5b pop %ebx 60: 8d 45 e4 lea -0x1c(%ebp),%eax d4: c9 leave 63: 83 ec 10 sub $0x10,%esp d5: c3 ret 66: 8b 4d d4 mov -0x2c(%ebp),%ecx
Object-oriented APIs for Vector processing Vector4f, Vector4i, Vector2d, Vector16b, etc Mapped to hardware operationsMono.SIMD: Mapping To Native InstructionsSIMD aware runtime• pos += deltaC#• call [Mono.Simd]Mono.Simd.Vector4f::op_Addition(valuetype [Mono.Simd]Mono.Simd.Vector4f, valuetype [Mono.Simd]Mono.Simd.Vector4f)IL•movups (%eax),%xmm0•movups (%edi),%xmm1•addps %xmm1,%xmm0•movups %xmm0,(%eax)x86DetectSIMDuset tI
UpdatePos With Mono’s SIMD00000000 <X_UpdatePos>: 0: 55 push %ebp 1: 8b ec mov %esp,%ebp 3: 53 push %ebx 4: 57 push %edi 5: 56 push %esi 6: 83 ec 04 sub $0x4,%esp 9: 8b 75 08 mov 0x8(%ebp),%esi c: 8b 7d 0c mov 0xc(%ebp),%edi f: 33 db xor %ebx,%ebx 11: eb 29 jmp 3c <X_UpdatePos+0x3c> 13: 8d 64 24 00 lea 0x0(%esp),%esp 17: 90 nop 18: 39 5e 0c cmp %ebx,0xc(%esi) 1b: 0f 86 2a 00 00 00 jbe 4b <X_UpdatePos+0x4b> 21: 8b cb mov %ebx,%ecx 23: c1 e1 04 shl $0x4,%ecx 26: 8b c6 mov %esi,%eax 28: 03 c1 add %ecx,%eax 2a: 05 10 00 00 00 add $0x10,%eax 2f: 0f 10 00 movups (%eax),%xmm0 32: 0f 10 0f movups (%edi),%xmm1 35: 0f 58 c1 addps %xmm1,%xmm0 38: 0f 11 00 movups %xmm0,(%eax) 3b: 43 inc %ebx 3c: 8b 46 0c mov 0xc(%esi),%eax 3f: 3b d8 cmp %eax,%ebx 41: 7c d5 jl 18 <X_UpdatePos+0x18> 43: 8d 65 f4 lea -0xc(%ebp),%esp 46: 5e pop %esi 47: 5f pop %edi 48: 5b pop %ebx 49: c9 leave 4a: c3 ret
SIMD Operations MixDeveloper created tests
Mono.SIMD: SpeedupsPhysics simulations, no optimizationsBased on the C++ simulation code at sharp-gamedev.blogspot.com/2008/09/updated-c-version.html
Ahead of Time compilation (AOT): “ngen” in the .NET world Precompiled IL code to native code Visible effects Saves on startup time Decreases footprint across multiple processes Produces slower code Not complete Can handle most of the JIT generated code A few bits are not AOTedAhead Of Time CompilationBatch compilation of CIL/.NET code
Some devices disable on the fly codegen: iPhone OS 2.x, XBox360 Full AOT: Does AOT for the missing bitsFull Ahead Of Time CompilationEntirely static compilation of CIL/.NET code
Demo – Mono on iPhone.
Mono Continuations Like Stackless-Python Cooperative multi-threading Avoids concurrency bugs Concurrency achieved with processes Supercomputing Mono 64 bit arraysOther TopicsMuch more
http://www.mono-project.com Getting Started http://www.mono-project.com/Start Community blogs http://www.go-mono.com/monologue Miguel’s blog http://tirania.org/blog Learning More About Mono
Evals & RecordingsPlease fill out your evaluation for this session at:This session will be available as a recording at:www.microsoftpdc.com
Please use the microphones providedQ&A
© 2008 Microsoft Corporation. All rights reserved. Microsoft, Windows, Windows Vista and other product names are or may be registered trademarks and/or trademarks in the U.S. and/or other countries.The information herein is for informational purposes only and represents the current view of Microsoft Corporation as of the date of this presentation. Because Microsoft must respond to changing market conditions, it should not be interpreted to be a commitment on the part of Microsoft, and Microsoft cannot guarantee the accuracy of any information provided after the date of this presentation. MICROSOFT MAKES NO WARRANTIES, EXPRESS, IMPLIED OR STATUTORY, AS TO THE INFORMATION IN THIS PRESENTATION.
Static Innovations Monos Innovations
Yıl : 2020
Anahtar Kelimeler
Daha fazla görüntüle