рдирдпрд╛ JIT рдЙрдкрд▓рдмреНрдз: рдЕрдм SIMD рд╕рдкреЛрд░реНрдЯ рдХреЗ рд╕рд╛рде

рдЕрдиреБрд╡рд╛рджрдХ рд╕реЗ



рдирд┐рдЬреА рддреМрд░ рдкрд░, рдореИрдВ рдирдП рдЕрд╡рд╕рд░ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдмрд╕ рдЕрд╡рд┐рд╢реНрд╡рд╕рдиреАрдп рд░реВрдк рд╕реЗ рдЦреБрд╢ рдерд╛ред рдЕрднреА рд╣рд╛рд▓ рд╣реА рдореЗрдВ, рдореИрдВрдиреЗ рдкреНрд░реЛред рдиреЗрдЯ рдкреНрд░рджрд░реНрд╢рди рдХреЛ рд╣рд░рд╛рдпрд╛, рдЬрд┐рд╕рдореЗрдВ рд╕реЗ рдПрдХ рдЕрдзреНрдпрд╛рдп рд╕рдорд╛рдирддрд╛рд╡рд╛рдж рдФрд░ рд╡рд┐рд╢реЗрд╖ рд░реВрдк рд╕реЗ рд╡реИрд╢реНрд╡реАрдХрд░рдг рдХреЗ рд▓рд┐рдП рд╕рдорд░реНрдкрд┐рдд рдерд╛ред рд▓реЗрдЦрдХреЛрдВ рджреНрд╡рд╛рд░рд╛ рдирд┐рд╖реНрдХрд░реНрд╖: "рджреБрд░реНрднрд╛рдЧреНрдп рд╕реЗ, рд╡реИрд╢реНрд╡реАрдХрд░рдг рдХрд╛ рдЙрдкрдпреЛрдЧ рд╡рд┐рд╢реЗрд╖ рд░реВрдк рд╕реЗ C ++ рдореЗрдВ рд╕рдВрднрд╡ рд╣реИред рдПрдХ рд╡реАрдбрд┐рдпреЛ рдХрд╛рд░реНрдб рдкрд░ рдХреЛрдб рдирд┐рд╖реНрдкрд╛рджрди .Net рдЙрдкрдХрд░рдг рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдирд╛ рд╕рдВрднрд╡ рд╣реИ, рд╣рд╛рд▓рд╛рдВрдХрд┐, C ++ AMP рдХрд┐рд╕реА рднреА рдкреНрд░рдмрдВрдзрд┐рдд GPGPU рдкреБрд╕реНрддрдХрд╛рд▓рдпреЛрдВ рдХреЛ рдмрд╣реБрдд рдкреАрдЫреЗ рдЫреЛрдбрд╝ рджреЗрддрд╛ рд╣реИ, рдЗрд╕рд▓рд┐рдП, рджреБрд░реНрднрд╛рдЧреНрдп рд╕реЗ, рд╣рдо рдЙрдкрдпреЛрдЧ рдХрд░ рд░рд╣реЗ рд╣реИрдВред рдкреНрд▓рдЧ-рдЗрди C ++ рдЕрд╕реЗрдВрдмрд▓реАред тАЭрдЗрд╕рд▓рд┐рдП, рдореБрдЭреЗ рдпрд╣ рд░рд┐рдкреЛрд░реНрдЯ рдХрд░рддреЗ рд╣реБрдП рдЦреБрд╢реА рд╣реЛ рд░рд╣реА рд╣реИ рдХрд┐ рдХрдо рд╕реЗ рдХрдо рдПрдХ рд╕рдорд╕реНрдпрд╛ рд╣рд▓ рд╣реЛ рдЧрдИ рд╣реИред рдЦреИрд░, рдЪрд▓реЛ рд╢реБрд░реВ рд╣реЛ рдЬрд╛рдУ!







рдкреНрд░рд╡рд┐рд╖реНрдЯрд┐





рдкреНрд░реЛрд╕реЗрд╕рд░ рдХрд╛ рдкреНрд░рджрд░реНрд╢рди рдореВрд░ рдХреЗ рдХрд╛рдиреВрди рдХреЗ рдЕрдзреАрди рдирд╣реАрдВ рд╣реИред рдЗрд╕рд▓рд┐рдП, рдЕрдиреБрдкреНрд░рдпреЛрдЧ рдкреНрд░рджрд░реНрд╢рди рдХреЛ рдмрдврд╝рд╛рдиреЗ рдХреЗ рд▓рд┐рдП, рд╕рдорд╛рдирд╛рдВрддрд░реАрдХрд░рдг рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдирд╛ рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реИред рдпрд╛, рдЬреИрд╕рд╛ рдХрд┐ рд╣рд░реНрдм рд╕рдЯрд░ рдиреЗ рдХрд╣рд╛, "рдХреЛрдИ рдФрд░ рдЕрдзрд┐рдХ рдореБрдлреНрдд рд╕реВрдк рдирд╣реАрдВ рд╣реЛрдЧрд╛" (рдореБрдлреНрдд рджреЛрдкрд╣рд░ рдХрд╛ рднреЛрдЬрди рдЦрддреНрдо рд╣реЛ рдЧрдпрд╛ рд╣реИ, рд▓реЗрдЦ рдХреЗ рд╕рдВрджрд░реНрдн рдореЗрдВ рдирд┐: рд╢реБрд▓реНрдХ рджреЛрдкрд╣рд░ рдХрд╛ рднреЛрдЬрди рдЦрддреНрдо рд╣реЛ рдЧрдпрд╛ рд╣реИ: рд╕реЙрдлреНрдЯрд╡реЗрдпрд░ рдореЗрдВ рдПрдХ рдореМрд▓рд┐рдХ рдЯрд░реНрдирдбрд░реНрдб рдХреЙрдирдПрдЬреЗрдВрд╕реА, рд░реВрд╕реА рдореЗрдВ рдЕрдиреБрд╡рд╛рдж )



рдЖрдк рд╕реЛрдЪ рд╕рдХрддреЗ рд╣реИрдВ рдХрд┐ рдХрд╛рд░реНрдп-рдЙрдиреНрдореБрдЦ рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рдХрд╛ рдЙрдкрдпреЛрдЧ ( рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, .net - TPL, рд▓рдЧрднрдЧред ) рдХреЗ рдорд╛рдорд▓реЗ рдореЗрдВред ) рдпрд╛ рдкрд╛рд░рдВрдкрд░рд┐рдХ рдзрд╛рдЧреЗ рдкрд╣рд▓реЗ рд╕реЗ рд╣реА рдЗрд╕ рд╕рдорд╕реНрдпрд╛ рдХреЛ рд╣рд▓ рдХрд░рддреЗ рд╣реИрдВред рдЬрдмрдХрд┐ рдорд▓реНрдЯреАрдереНрд░реЗрдбрд┐рдВрдЧ рдирд┐рд╢реНрдЪрд┐рдд рд░реВрдк рд╕реЗ рдПрдХ рдорд╣рддреНрд╡рдкреВрд░реНрдг рдХрд╛рд░реНрдп рд╣реИ, рдЖрдкрдХреЛ рдпрд╣ рд╕рдордЭрдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ рдХрд┐ рдкреНрд░рддреНрдпреЗрдХ рд╡реНрдпрдХреНрддрд┐рдЧрдд рдХреЛрд░ рдкрд░ рдЪрд▓рдиреЗ рд╡рд╛рд▓реЗ рдХреЛрдб рдХреЛ рдЕрдиреБрдХреВрд▓рд┐рдд рдХрд░рдирд╛ рдЕрднреА рднреА рдорд╣рддреНрд╡рдкреВрд░реНрдг рд╣реИред SIMD рдПрдХ рдРрд╕реА рддрдХрдиреАрдХ рд╣реИ рдЬреЛ рдкреНрд░реЛрд╕реЗрд╕рд░ рд╕реНрддрд░ рдкрд░ рдбреЗрдЯрд╛ рд╕рдорд╛рдВрддрд░рд┐рдХрд░рдг рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреА рд╣реИред рдорд▓реНрдЯреАрдереНрд░реЗрдбрд┐рдВрдЧ рдФрд░ SIMD рдПрдХ рджреВрд╕рд░реЗ рдХреЗ рдкреВрд░рдХ рд╣реИрдВ: рдорд▓реНрдЯреАрдереНрд░реЗрдбрд┐рдВрдЧ рдЖрдкрдХреЛ рдХрдИ рдкреНрд░реЛрд╕реЗрд╕рд░ рдХреЛрд░ рдкрд░ рдХрд╛рдо рдХреЛ рд╕рдорд╛рдирд╛рдВрддрд░ рдмрдирд╛рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИ, рдЬрдмрдХрд┐ SIMD рдЖрдкрдХреЛ рдПрдХ рд╣реА рдХреЛрд░ рдХреЗ рднреАрддрд░ рдХрд╛рдо рдХреЛ рд╕рдорд╛рдирд╛рдВрддрд░ рдмрдирд╛рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИред



рдЖрдЬ, рд╣рдо RyuJIT рдХреЗ рдирдП рдкреВрд░реНрд╡рд╛рд╡рд▓реЛрдХрди рд╕рдВрд╕реНрдХрд░рдг рдХреА рдШреЛрд╖рдгрд╛ рдХрд░рддреЗ рд╣реБрдП рдкреНрд░рд╕рдиреНрди рд╣реИрдВ, рдЬреЛ SIMD рдХрд╛рд░реНрдпрдХреНрд╖рдорддрд╛ рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИред SIMD рдПрдкреАрдЖрдИ рдирдП NuGet рдкреИрдХреЗрдЬ, Microsoft.Bcl.Simd рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рдЙрдкрд▓рдмреНрдз рд╣реИ, рдЬрд┐рд╕реЗ рдкреВрд░реНрд╡рд╛рд╡рд▓реЛрдХрди рдХреЗ рд░реВрдк рдореЗрдВ рднреА рдЬрд╛рд░реА рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИред



рдЖрдк рдЗрд╕рдХрд╛ рдЙрдкрдпреЛрдЧ рдХреИрд╕реЗ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдЗрд╕рдХрд╛ рдПрдХ рдЙрджрд╛рд╣рд░рдг рдЗрд╕ рдкреНрд░рдХрд╛рд░ рд╣реИ:



// Initalize some vectors Vector<float> values = GetValues(); Vector<float> increment = GetIncrement(); // The next line will leverage SIMD to perform the // addition of multiple elements in parallel: Vector<float> result = values + increment;
      
      







SIMD рдХреНрдпрд╛ рд╣реИ рдФрд░ рдореБрдЭреЗ рдЗрд╕рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рдХреНрдпреЛрдВ рд╣реИ?





SIMD рд╡рд░реНрддрдорд╛рди рдореЗрдВ рд╕рдмрд╕реЗ рдЕрдзрд┐рдХ рдорд╛рдВрдЧреА рдЬрд╛рдиреЗ рд╡рд╛рд▓реА рд╡рд┐рд╢реЗрд╖рддрд╛ рд╣реИ рдЬрд┐рд╕реЗ рдкреНрд▓реЗрдЯрдлрд╝реЙрд░реНрдо рдореЗрдВ рдЬреЛрдбрд╝рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд╣рд╛ рдЧрдпрд╛ рд╣реИ ( рд▓рдЧрднрдЧ 2000 рдЙрдкрдпреЛрдЧрдХрд░реНрддрд╛ рд╡реЛрдЯ )



рдЫрд╡рд┐



рдпрд╣ рдмрд╣реБрдд рд▓реЛрдХрдкреНрд░рд┐рдп рд╣реИ рдХреНрдпреЛрдВрдХрд┐, рдХреБрдЫ рдкреНрд░рдХрд╛рд░ рдХреЗ рдЕрдиреБрдкреНрд░рдпреЛрдЧреЛрдВ рдХреЗ рдЕрдкрд╡рд╛рдж рдХреЗ рд╕рд╛рде, SIMD рдХреЛрдб рдХреЛ рдХрд╛рдлреА рддреЗрдЬ рдХрд░рддрд╛ рд╣реИред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдПрдХ Mandelbrot рд╕реЗрдЯ рдХреЗ рд░реЗрдВрдбрд░рд┐рдВрдЧ рдкреНрд░рджрд░реНрд╢рди рдХреЛ SIMD рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдХрд╛рдлреА рд╕реБрдзрд╛рд░ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ: 2-3 рдмрд╛рд░ (рдпрджрд┐ рдкреНрд░реЛрд╕реЗрд╕рд░ SSE2 рдХрд╛ рд╕рдорд░реНрдерди рдХрд░рддрд╛ рд╣реИ), рдФрд░ 4-5 рдмрд╛рд░ (рдпрджрд┐ рдкреНрд░реЛрд╕реЗрд╕рд░ AVX рдХрд╛ рд╕рдорд░реНрдерди рдХрд░рддрд╛ рд╣реИ)ред



рдЫрд╡рд┐



рдЫрд╡рд┐



SIMD рдХрд╛ рдкрд░рд┐рдЪрдп





SIMD рдХрд╛ рдЕрд░реНрде "рдПрдХ рдХрдорд╛рдВрдб, рдвреЗрд░ рд╕рд╛рд░рд╛ рдбреЗрдЯрд╛" ( рдШрд░реЗрд▓реВ рд╕рдВрд╕реНрдХрд░рдг - OKMD, рд▓рдЧрднрдЧ рдкреНрд░рддрд┐ ) рд╣реИред рдпрд╣ рдкреНрд░реЛрд╕реЗрд╕рд░ рдирд┐рд░реНрджреЗрд╢реЛрдВ рдХрд╛ рдПрдХ рд╕реЗрдЯ рд╣реИ рдЬреЛ рдЖрдкрдХреЛ рд╕реНрдХреЗрд▓рд░ рдХреЗ рдмрдЬрд╛рдп рд╡реИрдХреНрдЯрд░ рдкрд░ рдХрд╛рдо рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИред рдЗрд╕рдХреЗ рдХрд╛рд░рдг, рдбреЗрдЯрд╛ рд╕реЗрдЯ рдкрд░ рдЧрдгрд┐рддреАрдп рд╕рдВрдЪрд╛рд▓рди рдХрд╛ рд╕рдорд╛рдирд╛рдВрддрд░ рдирд┐рд╖реНрдкрд╛рджрди рд╕рдВрднрд╡ рд╣реИред



SIMD рдЖрдкрдХреЛ рдЙрдЪреНрдЪ-рд╕реНрддрд░реАрдп рдЯреВрд▓ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдкреНрд░реЛрд╕реЗрд╕рд░ рд╕реНрддрд░ рдкрд░ рдбреЗрдЯрд╛ рдХреЛ рд╕рдорд╛рдирд╛рдВрддрд░ рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдХрд▓реНрдкрдирд╛ рдХрд░реЗрдВ рдХрд┐ рдЖрдкрдХреЗ рдкрд╛рд╕ рдмрд╣реБрдд рдЕрдзрд┐рдХ рд╕рдВрдЦреНрдпрд╛ рд╣реИ, рдФрд░ рдЖрдкрдХреЛ рдкреНрд░рддреНрдпреЗрдХ рдореЗрдВ рдХреБрдЫ рдореВрд▓реНрдп рдЬреЛрдбрд╝рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИред рдЖрдорддреМрд░ рдкрд░, рдЗрд╕ рд╕рдорд╕реНрдпрд╛ рдХреЛ рд╣рд▓ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП, рдПрдХ рдЪрдХреНрд░ рд▓рд┐рдЦрд╛ рдЬрд╛рддрд╛ рд╣реИ рдЬреЛ рдкреНрд░рддреНрдпреЗрдХ рддрддреНрд╡ рдХреЗ рд▓рд┐рдП рдХреНрд░рдорд┐рдХ рд░реВрдк рд╕реЗ рдЗрд╕ рдСрдкрд░реЗрд╢рди рдХреЛ рдХрд░рддрд╛ рд╣реИ:



 float[] values = GetValues(); float increment = GetIncrement(); // Perform increment operation as manual loop: for (int i = 0; i < values.Length; i++) { values[i] += increment; }
      
      







SIMD рдЖрдкрдХреЛ рд╡рд┐рд╢рд┐рд╖реНрдЯ CPU рдирд┐рд░реНрджреЗрд╢реЛрдВ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдХреЗ рдПрдХ рд╣реА рд╕рдордп рдореЗрдВ рдХрдИ рдорд╛рди рдЬреЛрдбрд╝рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрддрд╛ рд╣реИред рдпрд╣ рдЖрдорддреМрд░ рдкрд░ рдПрдХ рд╡реЗрдХреНрдЯрд░ рдкрд░ рдПрдХ рдСрдкрд░реЗрд╢рди рдХреА рддрд░рд╣ рджрд┐рдЦрддрд╛ рд╣реИ:



 Vector<float> values = GetValues(); Vector<float> increment = GetIncrement(); // Perform addition as a vector operation: Vector<float> result = values + increment;
      
      







рдпрд╣ рдзреНрдпрд╛рди рд░рдЦрдирд╛ рджрд┐рд▓рдЪрд╕реНрдк рд╣реИ рдХрд┐ рдПрдХ рд╕реЗ рдЕрдзрд┐рдХ SIMD рд╡рд┐рдирд┐рд░реНрджреЗрд╢ рд╣реИрдВред рдмрд▓реНрдХрд┐, рдкреНрд░рддреНрдпреЗрдХ рдкреНрд░реЛрд╕реЗрд╕рд░ рдХрд╛ рдЕрдкрдирд╛ SIMD рдХрд╛рд░реНрдпрд╛рдиреНрд╡рдпрди рд╣реИред рд╡реЗ рдЙрди рддрддреНрд╡реЛрдВ рдХреА рд╕рдВрдЦреНрдпрд╛ рдореЗрдВ рднрд┐рдиреНрди рд╣реЛрддреЗ рд╣реИрдВ рдЬрд┐рди рдкрд░ рдСрдкрд░реЗрд╢рди рдПрдХ рд╕рд╛рде рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ, рд╕рд╛рде рд╣реА рдЙрдкрд▓рдмреНрдз рдирд┐рд░реНрджреЗрд╢реЛрдВ рдХреЗ рд╕реЗрдЯ рдореЗрдВ рднреАред рдЗрдВрдЯреЗрд▓ / рдПрдПрдордбреА рдкреНрд░реЛрд╕реЗрд╕рд░ рдкрд░ рд╕рдмрд╕реЗ рдЖрдо SIMD рдХрд╛рд░реНрдпрд╛рдиреНрд╡рдпрди SSE2 рд╣реИред



рдпрд╣рд╛рдБ рдПрдХ рд╕рд░рд▓реАрдХреГрдд рдореЙрдбрд▓ рд╣реИ рдХрд┐ рдкреНрд░реЛрд╕реЗрд╕рд░ рд╕реНрддрд░ рдкрд░ SIMD рдХреИрд╕реЗ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИ:



  1. рдкреНрд░реЛрд╕реЗрд╕рд░ рдореЗрдВ рд╡рд┐рд╢реЗрд╖ SIMD рд░рдЬрд┐рд╕реНрдЯрд░ рд╣реИрдВред рдЙрдирдХрд╛ рдПрдХ рдирд┐рд╢реНрдЪрд┐рдд рдЖрдХрд╛рд░ рд╣реЛрддрд╛ рд╣реИред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, SSE2 рдХреЗ рд▓рд┐рдП, рдЖрдХрд╛рд░ 128 рдмрд┐рдЯреНрд╕ рд╣реИред
  2. рдкреНрд░реЛрд╕реЗрд╕рд░ рдореЗрдВ рд╡рд┐рд╢реЗрд╖ SIMD рдирд┐рд░реНрджреЗрд╢ рднреА рд╣реЛрддреЗ рд╣реИрдВ, рдЬреЛ рдСрдкрд░реЗрдВрдб рдХреЗ рдЖрдХрд╛рд░ рдкрд░ рдирд┐рд░реНрднрд░ рдХрд░рддрд╛ рд╣реИред рдкреНрд░реЛрд╕реЗрд╕рд░ рдХреЗ рджреГрд╖реНрдЯрд┐рдХреЛрдг рд╕реЗ, рдПрдХ SIMD рд░рдЬрд┐рд╕реНрдЯрд░ рдореЗрдВ рдбреЗрдЯрд╛ рдХреЗрд╡рд▓ рдмрд┐рдЯреНрд╕ рдХрд╛ рдПрдХ рд╕рдВрдЧреНрд░рд╣ рд╣реИред рд╣рд╛рд▓рд╛рдВрдХрд┐, рдбреЗрд╡рд▓рдкрд░ рдЗрди рдмрд┐рдЯреНрд╕ рдХреА рд╡реНрдпрд╛рдЦреНрдпрд╛ рдХрд░рдирд╛ рдЪрд╛рд╣рддрд╛ рд╣реИ, рдЬреИрд╕реЗ рдХрд┐, 32-рдмрд┐рдЯ рдкреВрд░реНрдгрд╛рдВрдХ рдХрд╛ рдПрдХ рд╕реЗрдЯред рдЗрд╕ рдкреНрд░рдпреЛрдЬрди рдХреЗ рд▓рд┐рдП, рдкреНрд░реЛрд╕реЗрд╕рд░ рдХреЗ рдкрд╛рд╕ рдХрд┐рдП рдЬрд╛рдиреЗ рд╡рд╛рд▓реЗ рдСрдкрд░реЗрд╢рди (рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдЗрд╕рдХреЗ рдЕрд▓рд╛рд╡рд╛) рдФрд░ рдСрдкрд░реЗрдВрдб рдХреЗ рдкреНрд░рдХрд╛рд░ (рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, 32-рдмрд┐рдЯ рдкреВрд░реНрдгрд╛рдВрдХ) рдХреЗ рд▓рд┐рдП рд╡рд┐рд╢рд┐рд╖реНрдЯ рдирд┐рд░реНрджреЗрд╢ рд╣реИрдВред





рдХрдИ рдХреНрд╖реЗрддреНрд░реЛрдВ рдореЗрдВ рд╕реЗ рдПрдХ рдЬрд╣рд╛рдБ SIMD рдмрд╣реБрдд рдЙрдкрдпреЛрдЧреА рд╣реИ рдЧреНрд░рд╛рдлрд┐рдХреНрд╕ рдФрд░ рдЧреЗрдо, рдЬреИрд╕реЗ:



рд╣рд╛рд▓рд╛рдВрдХрд┐, SIMD рдХрд┐рд╕реА рднреА рдкреНрд░рдХрд╛рд░ рдХреЗ рдЕрдиреБрдкреНрд░рдпреЛрдЧ рдкрд░ рд▓рд╛рдЧреВ рд╣реЛрддрд╛ рд╣реИ рдЬреЛ рдорд╛рдиреЛрдВ рдХреЗ рдПрдХ рдмрдбрд╝реЗ рд╕рдореВрд╣ рдкрд░ рд╕рдВрдЦреНрдпрд╛рддреНрдордХ рдХрд╛рд░реНрдп рдХрд░рддрд╛ рд╣реИред рдЗрд╕рдореЗрдВ рд╡реИрдЬреНрдЮрд╛рдирд┐рдХ рдЧрдгрдирд╛ рдФрд░ рд╡рд┐рддреНрдд рднреА рд╢рд╛рдорд┐рд▓ рд╣реИрдВред



рдХреЗ рд▓рд┐рдП SIMD рдбрд┐рдЬрд╛рдЗрди рдиреЗрдЯ





рдЕрдзрд┐рдХрд╛рдВрд╢ .NET рдбреЗрд╡рд▓рдкрд░реНрд╕ рдХреЛ CPU-рдирд┐рд░реНрднрд░ рдХреЛрдб рд▓рд┐рдЦрдирд╛ рдирд╣реАрдВ рдкрдбрд╝рддрд╛ рд╣реИред рдЗрд╕рдХреЗ рдмрдЬрд╛рдп, CLR рдПрдХ рд╡рд░реНрдЪреБрдЕрд▓ рдорд╢реАрди рдкреНрд░рджрд╛рди рдХрд░рдХреЗ рд╣рд╛рд░реНрдбрд╡реЗрдпрд░ рдХрд╛ рд╕рд╛рд░ рдХрд░рддрд╛ рд╣реИ рдЬреЛ рдЕрдкрдиреЗ рдХреЛрдб рдХреЛ рдорд╢реАрди рдирд┐рд░реНрджреЗрд╢реЛрдВ рдореЗрдВ рдпрд╛ рддреЛ рд░рди рдЯрд╛рдЗрдо (JIT) рдпрд╛ рдЗрдВрд╕реНрдЯрд╛рд▓реЗрд╢рди (NGEN) рдХреЗ рджреМрд░рд╛рди рдЕрдиреБрд╡рд╛рдж рдХрд░рддрд╛ рд╣реИред рд╕реАрдПрд▓рдЖрд░ рдХреЛрдб рдЬреЗрдирд░реЗрд╢рди рдХреЛ рдЫреЛрдбрд╝ рдХрд░, рдЖрдк рдЗрд╕ рд╡рд┐рд╢реЗрд╖ рд╕реАрдкреАрдпреВ рдХреЗ рд▓рд┐рдП рдСрдкреНрдЯрд┐рдорд╛рдЗрдЬрд╝реЗрд╢рди рджрд┐рдП рдмрд┐рдирд╛, рдЕрд▓рдЧ-рдЕрд▓рдЧ рдкреНрд░реЛрд╕реЗрд╕рд░ рд╡рд╛рд▓реЗ рд╡рд┐рднрд┐рдиреНрди рдХрдВрдкреНрдпреВрдЯрд░реЛрдВ рдкрд░ рдПрдХ рд╣реА MSIL рдХреЛрдб рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВред



рдпрд╣ рдЕрд▓рдЧрд╛рд╡ рд╡рд╣ рд╣реИ рдЬреЛ рд▓рд╛рдЗрдмреНрд░реЗрд░реА рдЗрдХреЛрд╕рд┐рд╕реНрдЯрдо рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдирд╛ рд╕рдВрднрд╡ рдмрдирд╛рддрд╛ рд╣реИ рдХреНрдпреЛрдВрдХрд┐ рдпрд╣ рдХреЛрдб рдХреЗ рдкреБрди: рдЙрдкрдпреЛрдЧ рдХреЛ рдмрд╣реБрдд рд╕рд░рд▓ рдХрд░рддрд╛ рд╣реИред рд╣рдо рдорд╛рдирддреЗ рд╣реИрдВ рдХрд┐ рд▓рд╛рдЗрдмреНрд░реЗрд░реА рдЗрдХреЛрд╕рд┐рд╕реНрдЯрдо рдореБрдЦреНрдп рдХрд╛рд░рдг рд╣реИред .NET рдРрд╕рд╛ рдЙрддреНрдкрд╛рджрдХ рд╡рд╛рддрд╛рд╡рд░рдг рд╣реИред



рдЗрд╕ рдкреГрдердХреНрдХрд░рдг рдХреЛ рдмрдирд╛рдП рд░рдЦрдиреЗ рдХреЗ рд▓рд┐рдП, рд╣рдореЗрдВ SIMD рдХреЗ рд▓рд┐рдП рдПрдХ рдкреНрд░реЛрдЧреНрд░рд╛рдорд┐рдВрдЧ рдореЙрдбрд▓ рдХреЗ рд╕рд╛рде рдЖрдирд╛ рдкрдбрд╝рд╛ рдЬреЛ SSE2 рдХреЗ рд▓рд┐рдП рдПрдХ рд╡рд┐рд╢рд┐рд╖реНрдЯ рдкреНрд░реЛрд╕реЗрд╕рд░ рдХрд╛рд░реНрдпрд╛рдиреНрд╡рдпрди рдХреЗ рд╕рдВрджрд░реНрдн рдХреЗ рдмрд┐рдирд╛ рд╡реЗрдХреНрдЯрд░ рд╕рдВрдЪрд╛рд▓рди рдХреЛ рд╡реНрдпрдХреНрдд рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рджреЗрдЧрд╛ред рд╣рдо рдПрдХ рдореЙрдбрд▓ рдХреЗ рд╕рд╛рде рдЖрдП, рдЬреЛ рд╡реЗрдХреНрдЯрд░ рдкреНрд░рдХрд╛рд░ рдХреА рджреЛ рд╢реНрд░реЗрдгрд┐рдпрд╛рдВ рдкреНрд░рджрд╛рди рдХрд░рддрд╛ рд╣реИ:



рдЫрд╡рд┐



рд╣рдо рдЗрди рджреЛ рд╢реНрд░реЗрдгрд┐рдпреЛрдВ рдХреЛ JIT- "рдмрд┐рд▓реНрдЯ-рдЗрди рдкреНрд░рдХрд╛рд░" рдХрд╣рддреЗ рд╣реИрдВред рдЗрд╕рдХрд╛ рдорддрд▓рдм рдпрд╣ рд╣реИ рдХрд┐ рдЬреЗрдЖрдИрдЯреА рдЗрди рдкреНрд░рдХрд╛рд░реЛрдВ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдЬрд╛рдирддрд╛ рд╣реИ рдФрд░ рдорд╢реАрди рдХреЛрдб рдмрдирд╛рддреЗ рд╕рдордп рдПрдХ рд╡рд┐рд╢реЗрд╖ рддрд░реАрдХреЗ рд╕реЗ рд╡реНрдпрд╡рд╣рд╛рд░ рдХрд░рддрд╛ рд╣реИред рд╣рд╛рд▓рд╛рдВрдХрд┐, рд╕рднреА рдкреНрд░рдХрд╛рд░ рдЙрди рдорд╛рдорд▓реЛрдВ рдореЗрдВ рднреА рдирд┐рд░реНрджреЛрд╖ рд░реВрдк рд╕реЗ рдХрд╛рдо рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдбрд┐рдЬрд╝рд╛рдЗрди рдХрд┐рдП рдЧрдП рд╣реИрдВ рдЬрд╣рд╛рдВ рдЙрдкрдХрд░рдг SIMD рдХрд╛ рд╕рдорд░реНрдерди рдирд╣реАрдВ рдХрд░рддреЗ рд╣реИрдВ (рдЬреЛ рдХрд┐ рдЖрдЬ рджреБрд░реНрд▓рдн рд╣реИ) рдпрд╛ рдПрдкреНрд▓рд┐рдХреЗрд╢рди RyuJIT рдХреЗ рдЗрд╕ рд╕рдВрд╕реНрдХрд░рдг рдХрд╛ рдЙрдкрдпреЛрдЧ рдирд╣реАрдВ рдХрд░рддрд╛ рд╣реИред рд╣рдорд╛рд░рд╛ рд▓рдХреНрд╖реНрдп рддрдм рднреА рд╕реНрд╡реАрдХрд╛рд░реНрдп рдкреНрд░рджрд░реНрд╢рди рдкреНрд░рджрд╛рди рдХрд░рдирд╛ рд╣реИ, рдЬрдм рдпрд╣ рдХреНрд░рдорд┐рдХ рд░реВрдк рд╕реЗ рд▓рд┐рдЦреЗ рдЧрдП рдХреЛрдб рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рд╣реЛред рджреБрд░реНрднрд╛рдЧреНрдп рд╕реЗ, рдЗрд╕ рдкреВрд░реНрд╡рд╛рд╡рд▓реЛрдХрди рдореЗрдВ рд╣рдордиреЗ рдЕрднреА рддрдХ рдпрд╣ рд╣рд╛рд╕рд┐рд▓ рдирд╣реАрдВ рдХрд┐рдпрд╛ рд╣реИред



рдирд┐рд╢реНрдЪрд┐рдд рдЖрдХрд╛рд░ рдХреЗ рд╡реИрдХреНрдЯрд░





рдЪрд▓рд┐рдП рдкрд╣рд▓реЗ рдирд┐рд╢реНрдЪрд┐рдд рдЖрдХрд╛рд░ рдХреЗ рд╡реИрдХреНрдЯрд░ рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдмрд╛рдд рдХрд░рддреЗ рд╣реИрдВред рдРрд╕реЗ рдХрдИ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рд╣реИрдВ рдЬреЛ рдкрд╣рд▓реЗ рд╕реЗ рд╣реА рдЕрдкрдиреЗ рд╕реНрд╡рдпрдВ рдХреЗ рд╡реЗрдХреНрдЯрд░ рдкреНрд░рдХрд╛рд░реЛрдВ рдХреЛ рдкрд░рд┐рднрд╛рд╖рд┐рдд рдХрд░рддреЗ рд╣реИрдВ, рд╡рд┐рд╢реЗрд╖ рд░реВрдк рд╕реЗ рдЧреНрд░рд╛рдлрд╝рд┐рдХрд▓ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдЬреИрд╕реЗ рдХрд┐ рдЧреЗрдо рдпрд╛ рд░реЗ рдЯреНрд░реЗрд╕рд░ред рдЬреНрдпрд╛рджрд╛рддрд░ рдорд╛рдорд▓реЛрдВ рдореЗрдВ, рдпреЗ рдЕрдиреБрдкреНрд░рдпреЛрдЧ рдлрд╝реНрд▓реЛрдЯрд┐рдВрдЧ рдкреЙрдЗрдВрдЯ рдФрд░ рдПрдХрд▓ рдкрд░рд┐рд╢реБрджреНрдзрддрд╛ рдорд╛рди рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реИрдВред



рдореБрдЦреНрдп рдкрд╣рд▓реВ рдпрд╣ рд╣реИ рдХрд┐ рдЗрди рд╡реИрдХреНрдЯрд░реЛрдВ рдореЗрдВ рдПрдХ рдирд┐рд╢реНрдЪрд┐рдд рд╕рдВрдЦреНрдпрд╛ рдореЗрдВ рддрддреНрд╡ рд╣реЛрддреЗ рд╣реИрдВ, рдЖрдорддреМрд░ рдкрд░ рджреЛ, рддреАрди рдпрд╛ рдЪрд╛рд░ред рджреЛ-рддрддреНрд╡ рд╡реИрдХреНрдЯрд░ рдХрд╛ рдЙрдкрдпреЛрдЧ рдЕрдХреНрд╕рд░ рдмрд┐рдВрджреБрдУрдВ рдпрд╛ рд╕рдорд╛рди рд╡рд╕реНрддреБрдУрдВ рдХрд╛ рдкреНрд░рддрд┐рдирд┐рдзрд┐рддреНрд╡ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ, рдЬреИрд╕реЗ рдХрд┐ рдЬрдЯрд┐рд▓ рд╕рдВрдЦреНрдпрд╛ред рддреАрди рдФрд░ рдЪрд╛рд░ рддрддреНрд╡реЛрдВ рд╡рд╛рд▓реЗ рд╡реЗрдХреНрдЯрд░реНрд╕ рдЖрдорддреМрд░ рдкрд░ 3 рдбреА рдХреЗ рд▓рд┐рдП рдЙрдкрдпреЛрдЧ рдХрд┐рдП рдЬрд╛рддреЗ рд╣реИрдВ (4 рд╡реЗрдВ рддрддреНрд╡ рдХрд╛ рдЙрдкрдпреЛрдЧ рдЧрдгрд┐рддреАрдп рдХрд╛рд░реНрдп рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ [ рдЬрд╛рд╣рд┐рд░ рд╣реИ, рд╣рдо рдЗрд╕ рддрдереНрдп рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдмрд╛рдд рдХрд░ рд░рд╣реЗ рд╣реИрдВ рдХрд┐ 3 рдбреА-рдореЙрдбрд▓рд┐рдВрдЧ рд░реВрдкрд╛рдВрддрд░рдг рдЪрд╛рд░-рдЖрдпрд╛рдореА рдореИрдЯреНрд░рд┐рдХреНрд╕ XYZ1



, рд▓рдЧрднрдЧ рдкреНрд░рддрд┐
) рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реИрдВ)ред рд▓рдмреНрдмреЛрд▓реБрдЖрдм рдпрд╣ рд╣реИ рдХрд┐ рдпреЗ рдХрд╛рд░реНрдп рдПрдХ рдирд┐рд╢реНрдЪрд┐рдд рд╕рдВрдЦреНрдпрд╛ рдореЗрдВ рддрддреНрд╡реЛрдВ рдХреЗ рд╕рд╛рде рд╡реИрдХреНрдЯрд░ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддреЗ рд╣реИрдВред



рдпрд╣ рджреЗрдЦрдиреЗ рдХреЗ рд▓рд┐рдП рдХрд┐ рдпреЗ рдкреНрд░рдХрд╛рд░ рдХреИрд╕реЗ рджрд┐рдЦрддреЗ рд╣реИрдВ, Vector3f



рд╕рд░рд▓реАрдХреГрдд рд╕рдВрд╕реНрдХрд░рдг рдХреЛ Vector3f



:

 public struct Vector3f { public Vector3f(float value); public Vector3f(float x, float y, float z); public float X { get; } public float Y { get; } public float Z { get; } public static bool operator ==(Vector3f left, Vector3f right); public static bool operator !=(Vector3f left, Vector3f right); // With SIMD, these element wise operations are done in parallel: public static Vector3f operator +(Vector3f left, Vector3f right); public static Vector3f operator -(Vector3f left, Vector3f right); public static Vector3f operator -(Vector3f value); public static Vector3f operator *(Vector3f left, Vector3f right); public static Vector3f operator *(Vector3f left, float right); public static Vector3f operator *(float left, Vector3f right); public static Vector3f operator /(Vector3f left, Vector3f right); }
      
      







рдореИрдВ рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдкрд╣рд▓реБрдУрдВ рдкрд░ рдЬреЛрд░ рджреЗрдирд╛ рдЪрд╛рд╣реВрдВрдЧрд╛:







рдбрд┐рд╡рд╛рдЗрд╕ рдЖрд╢реНрд░рд┐рдд рдХреНрд╖реЗрддреНрд░





рдЙрд╕ рд╕рдордп, рд╡реЗрдХреНрдЯрд░ рдкреНрд░рдХрд╛рд░ рдХреЗ рдирд┐рд╢реНрдЪрд┐рдд рдЖрдХрд╛рд░ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рд╕реБрд╡рд┐рдзрд╛рдЬрдирдХ рд╣реЛрддреЗ рд╣реИрдВ, рдЙрдирдХреЗ рдЕрдзрд┐рдХрддрдо рдЕрдВрд╢рд╛рдВрдХрди рдХреЛ рдШрдЯрдХреЛрдВ рдХреА рд╕рдВрдЦреНрдпрд╛ рд╕реЗ рд╕реАрдорд┐рдд рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдПрдХ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдЬреЛ рд╡реЗрдХреНрдЯрд░ 2 рдПрдл рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИ рдЙрд╕реЗ рдЕрдзрд┐рдХрддрдо рджреЛ рдмрд╛рд░ рддреНрд╡рд░рдг рдорд┐рд▓реЗрдЧрд╛, рднрд▓реЗ рд╣реА рд╕реАрдкреАрдпреВ рдПрдХ рд╕рд╛рде рдЖрда рддрддреНрд╡реЛрдВ рдкрд░ рд╕рдВрдЪрд╛рд▓рди рдХрд░рдиреЗ рдореЗрдВ рд╕рдХреНрд╖рдо рд╣реЛред



рд╣рд╛рд░реНрдбрд╡реЗрдпрд░ рдХреНрд╖рдорддрд╛рдУрдВ рдХреЗ рд╕рд╛рде рдкреИрдорд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдЖрд╡реЗрджрди рдХреЗ рд▓рд┐рдП, рдбреЗрд╡рд▓рдкрд░ рдХреЛ рдПрд▓реНрдЧреЛрд░рд┐рджрдо рдХреЛ рд╡реЗрдХреНрдЯрд░ рдХрд░рдирд╛ рд╣реЛрдЧрд╛ред рдПрд▓реНрдЧреЛрд░рд┐рдереНрдо рдХреЗ рд╡реЗрдХреНрдЯрд░рдХрд░рдг рдХрд╛ рдЕрд░реНрде рд╣реИ рдХрд┐ рдбреЗрд╡рд▓рдкрд░ рдХреЛ рдХрдИ рд╡реИрдХреНрдЯрд░ рдореЗрдВ рдЗрдирдкреБрдЯ рдорд╛рдкрджрдВрдбреЛрдВ рдХреЛ рддреЛрдбрд╝рдирд╛ рдЪрд╛рд╣рд┐рдП, рдЬрд┐рд╕рдХрд╛ рдЖрдХрд╛рд░ рдЙрдкрдХрд░рдг рдкрд░ рдирд┐рд░реНрднрд░ рдХрд░рддрд╛ рд╣реИред SSE2 рдХреЗ рд╕рд╛рде рдПрдХ рдорд╢реАрди рдкрд░, рдЗрд╕рдХрд╛ рдорддрд▓рдм рд╣реИ рдХрд┐ рдПрдкреНрд▓рд┐рдХреЗрд╢рди рдЪрд╛рд░ 32-рдмрд┐рдЯ рдлреНрд▓реЛрдЯрд┐рдВрдЧ рдкреЙрдЗрдВрдЯ рдирдВрдмрд░ рдХреЗ рд╡реИрдХреНрдЯрд░ рдкрд░ рдХрд╛рдо рдХрд░ рд╕рдХрддрд╛ рд╣реИред рдПрд╡реАрдПрдХреНрд╕ рдХреЗ рд╕рд╛рде рдПрдХ рдорд╢реАрди рдкрд░, рдПрдХ рд╣реА рдЖрд╡реЗрджрди рдЖрда рдРрд╕реЗ рдирдВрдмрд░реЛрдВ рдХреЗ рд╡реИрдХреНрдЯрд░ рдкрд░ рдХрд╛рдо рдХрд░ рд╕рдХрддрд╛ рд╣реИред



рдЕрдВрддрд░ рдХреЗ рд▓рд┐рдП рд╕рдордЭрдиреЗ рдХреЗ рд▓рд┐рдП, рдиреАрдЪреЗ рдПрдХ рд╕рд░рд▓реАрдХреГрдд рд╕рдВрд╕реНрдХрд░рдг рд╣реИ
 Vector: 
      

public struct Vector<T> where T : struct { public Vector(T value); public Vector(T[] values); public Vector(T[] values, int index); public static int Length { get; } public T this[int index] { get; } public static bool operator ==(Vector<T> left, Vector<T> right); public static bool operator !=(Vector<T> left, Vector<T> right); // With SIMD, these element wise operations are done in parallel: public static Vector<T> operator +(Vector<T> left, Vector<T> right); public static Vector<T> operator &(Vector<T> left, Vector<T> right); public static Vector<T> operator |(Vector<T> left, Vector<T> right); public static Vector<T> operator /(Vector<T> left, Vector<T> right); public static Vector<T> operator ^(Vector<T> left, Vector<T> right); public static Vector<T> operator *(Vector<T> left, Vector<T> right); public static Vector<T> operator *(Vector<T> left, T right); public static Vector<T> operator *(T left, Vector<T> right); public static Vector<T> operator ~(Vector<T> value); public static Vector<T> operator -(Vector<T> left, Vector<T> right); public static Vector<T> operator -(Vector<T> value); }








:



. , - , Vector. ,



. int



, long



, float



double



. , .








. , , Length. sizeof(SIMD-register) / sizeof(T)



. , Vector Vector , T1



T2



. , .














- , , . , , . . , , . , .



SIMD, , Vector2f



. ( ) ( ). , . , .



, . , .



- SIMD



:



RyuJIT, SIMD NuGet, SIMD



NuGet SIMD / JIT. IL. ,, RyuJIT.



SIMD, :



RyuJIT aka.ms/RyuJIT JIT SIMD . , :



@echo off set COMPLUS_AltJit=* set COMPLUS_FeatureSIMD=1 start myapp.exe





NuGet- Microsoft.Bcl.Simd



. , Manage NuGet References



. Online



. , Include Prelease



. Microsoft.Bcl.Simd



. Install



.



, , , :



SIMD 64- . , x64, Any CPU, 32- Vector



int, long, float double. Vector .







SIMD SSE2. , RyuJIT CTP . AVX .NET, RyuJIT. , () CTP.

.



. ? ? ? , ryujit(at)microsoft.com.




Vector:

public struct Vector<T> where T : struct { public Vector(T value); public Vector(T[] values); public Vector(T[] values, int index); public static int Length { get; } public T this[int index] { get; } public static bool operator ==(Vector<T> left, Vector<T> right); public static bool operator !=(Vector<T> left, Vector<T> right); // With SIMD, these element wise operations are done in parallel: public static Vector<T> operator +(Vector<T> left, Vector<T> right); public static Vector<T> operator &(Vector<T> left, Vector<T> right); public static Vector<T> operator |(Vector<T> left, Vector<T> right); public static Vector<T> operator /(Vector<T> left, Vector<T> right); public static Vector<T> operator ^(Vector<T> left, Vector<T> right); public static Vector<T> operator *(Vector<T> left, Vector<T> right); public static Vector<T> operator *(Vector<T> left, T right); public static Vector<T> operator *(T left, Vector<T> right); public static Vector<T> operator ~(Vector<T> value); public static Vector<T> operator -(Vector<T> left, Vector<T> right); public static Vector<T> operator -(Vector<T> value); }








:



. , - , Vector. ,



. int



, long



, float



double



. , .








. , , Length. sizeof(SIMD-register) / sizeof(T)



. , Vector Vector , T1



T2



. , .














- , , . , , . . , , . , .



SIMD, , Vector2f



. ( ) ( ). , . , .



, . , .



- SIMD



:



RyuJIT, SIMD NuGet, SIMD



NuGet SIMD / JIT. IL. ,, RyuJIT.



SIMD, :



RyuJIT aka.ms/RyuJIT JIT SIMD . , :



@echo off set COMPLUS_AltJit=* set COMPLUS_FeatureSIMD=1 start myapp.exe





NuGet- Microsoft.Bcl.Simd



. , Manage NuGet References



. Online



. , Include Prelease



. Microsoft.Bcl.Simd



. Install



.



, , , :



SIMD 64- . , x64, Any CPU, 32- Vector



int, long, float double. Vector .







SIMD SSE2. , RyuJIT CTP . AVX .NET, RyuJIT. , () CTP.

.



. ? ? ? , ryujit(at)microsoft.com.







All Articles