SoloCodigo

Saludos,

Tengo una duda acerca de cual de estas dos instrucciones es mas rapida ya que las necesito en un proceso que se ejecuta miles de veces .


El punto es que en variable deben quedar solo los bits  3,4,5 de la variable variableA.

Ya he probado ambos y ambos me funcionan produciendo los resultados esperados pero me interesa saber cual tiene un mejor desempeño en el procesador y desde luego cual es la razon de la respuesta.


Gracias.

Bueno ese es un buen dato, vere si hay documentacion para procesadores Pentium y  posteriores que son mi objetivo mas general .

SHL   ? debe ser << porque no conozco nada en C/C++/C# que haga ROL alguien sabe de alguno?

OK, bueno he hecho pruebas que tardan hasta 4 segundos con bitmaps uno de

955 * 581 * 3 = 1.58 mb

y otro

868 * 979 * 3 = 2.43 mb

es decir la prueba la hice con los dos al tiempo ( 4.01 mb).

pero mi objetivo es que no tarden ni un segundo, maximo uno.

bueno encontre esto que no me aclara mucho el panorama porque aun hay diferencia.

Seguire tu consejo y vere si puedo en un rato sacar algo de tiempo para un bitmap grande.

Bueno, nmo he encontrado diferemcias visibles con dos bmp de 1440 * 900 * 3  


asi que dejare cualquiera de los dos.


gracias.

Entonces probablemente esto no se ejecute miles de veces seguidas sino espaciadas  

Gracias por los consejos.

Bueno he revisado el codigo paso por paso y si bien esa parte toma una parte considerable del tiempo, no es la mas representativa.

Habia pasado por alto algunos detalles y resulta que el problema principal es cuando trato de importar un archivo bmp para convertirlo en un cuadro de mi formato de archivo, puesto que el formato BMP tiene formato de color BRG y el mio tiene formato color RGB asi que lo que haga es extraer los colores del BMP y crear un array de colores en el formato correcto...hace esto:


Para el ejemplo de las imagenes citadas anteriormente este ciclo iteraria 2'592.000 veces, y el tamaño de bmpArr seria más de 7'776.000 bytes.

donde

T es un tipo generico de Color, el constructor vacio no hace nada
colorArray es un T[]
bmpArr es un byte [] con la informacion de los bytes del bmp, incluyendo los bytes de padding
FromBMPColorArray es un metodo que extrae un color del array del bmp y lo convierte al color con formato RGB.. es decir para el caso de un color de 24 bits hace:


baseType es un Int32 que representa el color.

La verdad no tengo ni la mas remota idea de como optimizarlo más. Acepto cualquier sugerencia por descabellada que sea ( pero que sea posible de hacer)    

Gracias!!!

 no tomare eso como una opcion    de no poder al final hacer nada preferiria dejar lo así.  

Ademas en todo caso deberia extraer la informacion del bmp y copiarla en un arreglo propio de objetos tipo T  /* color*/ y ya sin padding.

En vez de usar memoria estatica que es una practica de programacion pesima podrias tratar de reservar directamente toda la memoria necesaria para ese bitmap y no linea por linea.

Using the register keyword in strategic places C will improve performance substantially.
This keyword is a complete placebo in most modern C compilers.

Realmente hay una altisima probabilidad de que esto sea una perdida de tiempo absoluta. No tiene sentido intentar hacer esto con C# ya que no es la herramienta adecuada, si lo es para que el programa llegue a buen puerto y sea completado en el menor tiempo posible, con la mayor simplicidad y con gran posibilidad de reutilizar el codigo generado y que este sea generado en gran parte de la misma forma pero estas ventajas (entre otras mas) se vuelven desventajas a la hora de optimizar ya que se pierde el control del codigo generado.

Bueno, tengo algunos ajustes en mente para hacer...
pero mientras, y antes de empezar en forma ( estaba de viaje) quisiera saber algo.

que tan importante es el consumo de memoria a la hora de medir el performance en millones de ciclos?

Si tengo una clase X con campos y metodos que tan mas eficiente seria dejar todos sus metodos esticos versus versiones diferentes de los mismos metodos pero no estaticos?

Es decir reservar 2'500.000 porciones de memoria de tamaño N/x es más rápido que reservar 2'500.000 porciones de memoria de tamaño N?  

Si eso he visto en las pruebas que he realizado hoy... ahora solo me falta averiguar como demonios hago en C# para reservar un bloque de memoria y asignarlo aun lote de 'punteros' que se encuentran un array  

thanks

He solucionado el problema de velocidad    

Pero desde luego no fue precisamente una solucion muy limpia, por el contrario bastante sucia.

Como el problema es por usar generics decidi reducir su uso al maximo en ese metodo porblema, asi que lo que hice fue determinar el tipo T e implementar una solucion especifica para los tipos soportados por mis formatos nativamente (8,16,24,32 bit) y conservar la interfaz generica para los clientes del metodo asi como proveer una solucion generica para los tipos no nativos que se requieran utilizar en un futuro.

Reduje el tiempo de ejecucion a menos de un segundo.  

Codigo anterior:

<!--xc1--></div><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>XCODE </td></tr><tr><td id='XCODE'><!--exc1-->
        public T[] ColorArrayDesdeBMP(Bitmap bmp)
        {
            T[] colorArray = new T[bmp.Height * bmp.Width];
            BitmapData bmpd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat);
            IntPtr pbmp = bmpd.Scan0;
            byte bytesPorPixel = 0;
            int j = 0;

            bytesPorPixel = (byte)((int)imagen.informacionBase.ProfundidadColor / 8);
            int anchoEnBytes = bmp.Width * bytesPorPixel;
            int paddedBytes = ((anchoEnBytes + 3) & ~3) - anchoEnBytes;
            int anchoBytesPadd = anchoEnBytes + paddedBytes;
            byte[] bmpArr = new byte[bmp.Height * anchoBytesPadd];

            System.Runtime.InteropServices.Marshal.Copy(pbmp, bmpArr, 0, bmp.Height * anchoBytesPadd);
            bmp.UnlockBits(bmpd);

            for (int i = 0; i < bmpArr.Length; i += bytesPorPixel)
            {
                colorArray[j] = new T();
                colorArray[j++].FromBMPColorArray(bmpArr, i);
                if (j % bmp.Width == 0)
                    i += paddedBytes;
            }

            return colorArray;
        }<!--xc2--></td></tr></table><div class='postcolor'><!--exc2-->

Codigo nuevo (cochino pero rapido)


<!--xc1--></div><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>XCODE </td></tr><tr><td id='XCODE'><!--exc1-->        public T[] ColorArrayDesdeBMP(Bitmap bmp)
        {
            BaseColor[] objectArray = new BaseColor[bmp.Height * bmp.Width];
            T[] colorArray= new T[1];
            Color8[] colorArray8 = new Color8[1];
            Color16[] colorArray16 = new Color16[1];
            Color24[] colorArray24 = new Color24[1];
            Color32[] colorArray32 = new Color32[1];

            BitmapData bmpd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat);
            IntPtr pbmp = bmpd.Scan0;
            byte bytesPorPixel = (byte)((int)imagen.informacionBase.ProfundidadColor / 8);
            int anchoEnBytes = bmp.Width * bytesPorPixel;
            int paddedBytes = ((anchoEnBytes + 3) & ~3) - anchoEnBytes;
            int anchoBytesPadd = anchoEnBytes + paddedBytes;
            byte[] bmpArr = new byte[bmp.Height * anchoBytesPadd];

            Type t = typeof(T);
            int j = 0;

            System.Runtime.InteropServices.Marshal.Copy(pbmp, bmpArr, 0, bmp.Height * anchoBytesPadd);
            bmp.UnlockBits(bmpd);

            switch (t.Name)
            {
                case "Color8":
                    colorArray8 = Array.ConvertAll<BaseColor, Color8>(objectArray, delegate(BaseColor b) { return b as Color8; });
                    for (int i = 0; i < bmpArr.Length; i += bytesPorPixel)
                    {
                        colorArray8[j] = new Color8();
                        colorArray8[j++].FromBMPColorArray(bmpArr, i);
                        if (j % bmp.Width == 0)
                            i += paddedBytes;
                    }
                    return colorArray8 as T[];
                case "Color16":
                    colorArray16 = Array.ConvertAll<BaseColor, Color16>(objectArray, delegate(BaseColor b) { return b as Color16; });
                    for (int i = 0; i < bmpArr.Length; i += bytesPorPixel)
                    {
                        colorArray16[j] = new Color16();
                        colorArray16[j++].FromBMPColorArray(bmpArr, i);
                        if (j % bmp.Width == 0)
                            i += paddedBytes;
                    }
                    return colorArray16 as T[];
                case "Color24":
                    colorArray24 = Array.ConvertAll<BaseColor, Color24>(objectArray, delegate(BaseColor b) { return b as Color24; });
                    for (int i = 0; i < bmpArr.Length; i += bytesPorPixel)
                    {
                        colorArray24[j] = new Color24();
                        colorArray24[j++].FromBMPColorArray(bmpArr, i);
                        if (j % bmp.Width == 0)
                            i += paddedBytes;
                    }
                    return colorArray24 as T[];
                case "Color32":
                    colorArray32 = Array.ConvertAll<BaseColor, Color32>(objectArray, delegate(BaseColor b) { return b as Color32; });
                    for (int i = 0; i < bmpArr.Length; i += bytesPorPixel)
                    {
                        colorArray32[j] = new Color32();
                        colorArray32[j++].FromBMPColorArray(bmpArr, i);
                        if (j % bmp.Width == 0)
                            i += paddedBytes;
                    }
                    return colorArray32 as T[];
                default:
                    colorArray = Array.ConvertAll<BaseColor, T>(objectArray, delegate(BaseColor b) { return b as T; });
                    for (int i = 0; i < bmpArr.Length; i += bytesPorPixel)
                    {
                        colorArray[j] = new T();
                        colorArray[j++].FromBMPColorArray(bmpArr, i);
                        if (j % bmp.Width == 0)
                            i += paddedBytes;
                    }

                    return colorArray;
            }
        }<!--xc2--></td></tr></table><div class='postcolor'><!--exc2-->