   Yes I'm an optimization freak
  I just wanted to know, is the operation3 / 2or the operation3 * .5faster on an Intel-based processor.Thanx for any suggestions!(Oh and please dont post anything about "it doesnt matter" unless it really doesnt matter)Edit:To expand on that, is the operation2 * (4 / 5)faster than2 * .8Edit:Assume all values are stored as floats   
  well, considering that todays technology you could presume that takes 1/1207833498789 of the processor to do maybe smaller lol... but considering the circumstances it would be faster doing 2 * .8 because it only has to do ONE mathmatic equation where at 2 * (4/5) it has to do two   ;  Not sure but I think this is faster then both3 >> 1;of course that wont work with floats but if your focased with optomization that much there has to be sacrifices.   ;  If you have something like this:3 * (4/5)And everything is constants, not variables, then the compiler "SHOULD" figure it out at compile time.At run time, doing 4/5 would be longer than .8 because of the extra instruction, I think.   ;  It doesn't matter.  Every single change you suggest can be trivially performed by the compiler if needed.  So, it doesn't matter.  Write code that is easy to understand, and let people with more information than you worry about the details.CM   ;Quote:Original post by geekalert(Oh and please dont post anything about "it doesnt matter" unless it really doesnt matter)It really doesn't matter.   ;  yes as stated above the compiler will do LOW LEVEL optimzation, the thing that you as a programmer must be concerned with is high level opimization. For example while(I < 300)  I++;   ///<-- the compiler wont optomize this, obivious as the ineffeiciency isas opposed toI = 300;this is a really simple example but hopefully you get what I mean;Quote:Original post by raptorstrikeyes as stated above the compiler will do LOW LEVEL optimzation, the thing that you as a programmer must be concerned with is high level opimization. For example while(I < 300)  I++;   ///<-- the compiler wont optomize this, obivious as the ineffeiciency isas opposed toI = 300;this is a really simple example but hopefully you get what I meanThis even is a bad example - the compiler will reduce that to i = 300.(tested under VC toolkit 2k3).Cheers,Pat.PS: Micro-optimisation is pointless unless profiler outcome suggests to do it.;  Back to the topic. If you have really floats and not constants, there is a HUGE difference in performance! Obviously the calculation with 3 numbers is the slowest and multiplication should be faster than divisions.I wrote a little test app doing each of your calculations 1 billion times, here is the result:3/2=1,5took 3662791ns3*0,5=1,5   took 1371114ns2*(4/5)=1,6 took 7788465ns2*0,8=1,6   took 1366573nsAnd the sourcecode (c#, but test it in c++ or assembler if you want to ...):// Project: TestAddMultPerformance, File: Program.cs// Namespace: TestAddMultPerformance, Class: Program// Path: C:\code\TestAddMultPerformance, Author: Abi// Code lines: 107, Size of file: 2,96 KB// Creation date: 30.12.2005 07:16// Last modified: 30.12.2005 07:25// Generated with Commenter by abi.exDream.com#region Using directivesusing System;using System.Collections.Generic;using System.Text;using System.Runtime.InteropServices;#endregionnamespace TestAddMultPerformance{/// <summary>/// Program/// </summary>class Program{#region Performance counters and getting ns time/// <summary>/// Query performance (high resolution) timer frequency/// </summary>/// <param name="lpFrequency">current frequency</param>[System.Security.SuppressUnmanagedCodeSecurity][DllImport("Kernel32.dll")][return: MarshalAs(UnmanagedType.Bool)]internal static extern bool QueryPerformanceFrequency(out long lpFrequency);/// <summary>/// Query performance (high resolution) timer counter/// </summary>/// <param name="lpCounter">current counter value</param>[System.Security.SuppressUnmanagedCodeSecurity][DllImport("Kernel32.dll")][return: MarshalAs(UnmanagedType.Bool)]internal static extern bool QueryPerformanceCounter(out long lpCounter);/// <summary>/// Get current performance timer frequency/// (using QueryPerformanceFrequency)/// </summary>public static long GetPerformanceFrequency(){long l;QueryPerformanceFrequency(out l);return l;} // GetPerformanceFrequency()/// <summary>/// Get current performance timer counter value/// (using QueryPerformanceCounter)/// </summary>public static long GetPerformanceCounter(){long l;QueryPerformanceCounter(out l);return l;} // GetPerformanceCounter()/// <summary>/// Remember the frequency/// </summary>public static long performanceFrequency = GetPerformanceFrequency();/// <summary>/// Convert performance counter value to ns./// </summary>/// <param name="perfCounter">Counter difference from 2 values</param>static public int ConvertToNs(long perfCounter){return (int)(perfCounter * 1000000 / performanceFrequency);} // ConvertToNs(perfCounter)/// <summary>/// Convert performance counter value difference/// (perfCounter2-perfCounter1) to ns./// </summary>static public int ConvertToNs(long perfCounter1, long perfCounter2){return (int)((perfCounter2 - perfCounter1) *1000000 / performanceFrequency);} // ConvertToNs(perfCounter1, perfCounter2)#endregionstatic void Main(string[] args){// Declare everything here in case this eats up cyclesfloat ret = 0.0f;float value1 = 3;float value2 = 2;float value3 = 1 / value2;float value4 = 4;float value5 = 5;float value6 = value4 / value5;long perfCounterBefore, perfCounterAfter;// Do 1 bio iterations.int numberOfIterations = 1000 * 1000 * 1000;// Just call every method once to make sure we don't count any JIT time.perfCounterBefore = GetPerformanceCounter();for (int i = 0; i < numberOfIterations; i++){ret = value1 / value2;} // forperfCounterAfter = GetPerformanceCounter();Console.WriteLine("Dummy test to init JIT: "+value1 + "/" + value2 + "=" + ret + " took " +ConvertToNs(perfCounterBefore, perfCounterAfter) + "ns");// Test1perfCounterBefore = GetPerformanceCounter();for (int i = 0; i < numberOfIterations; i++){ret = value1 / value2;} // forperfCounterAfter = GetPerformanceCounter();Console.WriteLine(value1 + "/" + value2 + "=" + ret + " took " +ConvertToNs(perfCounterBefore, perfCounterAfter) + "ns");// Test2perfCounterBefore = GetPerformanceCounter();for (int i = 0; i < numberOfIterations; i++){ret = value1 * value3;} // forperfCounterAfter = GetPerformanceCounter();Console.WriteLine(value1 + "*" + value3 + "=" + ret + " took " +ConvertToNs(perfCounterBefore, perfCounterAfter) + "ns");// Test3perfCounterBefore = GetPerformanceCounter();for (int i = 0; i < numberOfIterations; i++){ret = value2 * (value4 / value5);} // forperfCounterAfter = GetPerformanceCounter();Console.WriteLine(value2 + "*(" + value4 + "/" + value5 + ")=" + ret + " took " +ConvertToNs(perfCounterBefore, perfCounterAfter) + "ns");// Test4perfCounterBefore = GetPerformanceCounter();for (int i = 0; i < numberOfIterations; i++){ret = value2 * value6;} // forperfCounterAfter = GetPerformanceCounter();Console.WriteLine(value2 + "*" + value6 + "=" + ret + " took " +ConvertToNs(perfCounterBefore, perfCounterAfter) + "ns");Console.ReadLine();} // Main(args)} // class Program} // namespace TestAddMultPerformanceAnd obviously this is nothing to consider when coding normal algorithms, but it is never bad to know these things :)   ;Quote:Original post by raptorstrikeyes as stated above the compiler will do LOW LEVEL optimzation, the thing that you as a programmer must be concerned with is high level opimization. For example while(I < 300)  I++;   ///<-- the compiler wont optomize this, obivious as the ineffeiciency isas opposed toI = 300;this is a really simple example but hopefully you get what I meanWhile your point is both valid and important, I'll bet that if you check, a good compiler does indeed optimize that.CM   