SoloCodigo

Este post es de ahce mas de dos años, no vale la pena revivirlo.

Si buscas DDK en este foro encontraras algo de informacion ... es un camino largo y muy duro ... la mayoria no lo termina ...

O ni empieza  

Espero algun dia de verdad dedicarle tiempo.

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-->

Haicendo averiguaciones y pruebas , resulta que hacer la misma implementacion usando tipos como clases o estucturas, la instanciacion de 2'500.000 elementos es casi inmediata, como 1/2 segundo mientras que usado generics ( el equivalente a templates en c++, el cual es mi caso) toma casi 5 segundos.    tal como lo dijo eternal idol se acelera el tiempo de desarrollo pero con un costo de performance adicional.

Estas cifras las obtuve tambien en un foro de Microsoft:

new int(): 0.006 microseconds
new T() where T is int: 0.030 microseconds
new class(): 0.042 microseconds
new T() where T is class: 2.0 microseconds

Este es el link:

http://forums.microsoft.com/MSDN/ShowPost....SiteID=1&mode=1

No acepto burlas por mi ingles, pues apenas estoy aprendiendo.

Bueno por el momento no se que hacerle , si bien es un tiempo significativo lo puedo considerar como despreciable puesto que esta por demas decir que esta por fuera de mi scope ya que el formato va dirigido a animaciones para videojuego y dificilmente algun cuadro de animacion llegara a ese tamaño de imagen, de hecho ni a la mitas de ese tamaño con el cual hice las pruebas, sin embargo si se me ocurre algo como lo del pool de tipos T pues puede que llegue a implementarlo.

Hablamos.  

this es un puntero al objeto actual.

Es decir si estas dentro de la calse Forma1 y haces this.cosa1 te estas referiendo a la variable cosa1 definida dentro de Forma1. siemopre hace referencia al objeto actual.

Es muy util sobre todo cuando un constructor o metodo reciben como parametros variables con el mismo nombre de una variable  que ya esta definida dentro de la clase, ya que sino usas this, ni tu ni el compilador tendrian forma de diferenciarlas.

ejemplo:

Existe direct show dentro de direct X???

hasta donde recuerdo esta en el Windows SDK movere este post al foro de Windows.

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?  

quizas tiene algun error, yo ya no programo en C pero bueno...
una duda... C# todabia tiene puntero ??? espero que si

espero te ayude...

Si, C# tiene punteros..
sin embargo tu alternativa presenta un alto impacto en el codigo fuente dependiente de ese modulo...
vere si puedo hacer algo hibrido o que se yo.

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.

Claro tienees mucha razon, para cosas de mision critica nda como C++/C y asm  

pero en todo caso no me dare por vencido.

espero poder hacer algo.

luego les cuento.

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!!!

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.

 

En efecto, con globus puedes compartir incluso todos los recursos de cada maquina para con las otras, a discrecion de la configuracion.

Desde luego recursos se entiende todo, software , perofericos, memoria, procesador etc.

yo escucho de muchos tipos de musica, principalmente:

Metal
Musica electronica
Musica Clasica
New Age
Pop

Reggueaton como musica lo odio... pero los disfruto mucho bailando es una delicia y una gran tentacion.

Tambien escucho

reague
hip hop

Y en menor grado
Salsa, merengue
y la musica de tradicion (vallenato, cumbia, etc.) asi como la musica 'de planchar' ( rocio duircal, roberto carlos , jose luis perales etc)