Ruby 1.9 más lento que Ruby 1.8?

Question

Tengo una aplicación Rails 2.3.8 con una acción que extrae una gran cantidad de datos de una base de datos y la renderiza con entre 300 y 600 parciales (representando recursivamente una estructura tipo árbol). La evaluación comparativa de una solicitud me da tiempos de respuesta de aproximadamente 7 segundos.

Pensé que actualizar mi versión de Ruby a 1.9 desde 1.8 me daría una mejora en el rendimiento, pero como comparativo de la versión 1.9, obtengo tiempos de respuesta de unos 9 segundos (2 segundos más lento que en 1.8). Esto fue bastante sorprendente para mí.

¿Qué factores causarían que Ruby 1.9 se ejecute más lento que Ruby 1.8?

A continuación se muestra una parte del archivo de registro.

Rubí 1,8

Rendered family_index/descendants/_fi_hover (0.5ms) 
Rendered family_index/descendants/_descendant (4.6ms) 
Rendered search/_search_div (0.1ms) 
Rendered family_index/descendants/_fi_hover (0.7ms) 
Rendered family_index/descendants/_descendant (4.7ms) 
Rendered search/_search_div (0.1ms) 
Rendered family_index/descendants/_fi_hover (0.5ms) 
Rendered family_index/descendants/_descendant (4.5ms) 
Rendered family_index/descendants/_fi_hover (0.5ms) 
Rendered family_index/descendants/_descendant (37.9ms) 
Rendered family_index/surname_groups/_pedigree (3162.9ms) 
Rendered shared/_headers (4.6ms) 
Rendered shared/_new_messages (0.6ms) 
Rendered shared/_home_logo (1.1ms) 
Rendered shared/_login_box (4.0ms) 
Rendered shared/_navigation (13.6ms) 
Rendered shared/_flash_messages (0.8ms) 
Rendered shared/_footer (1.0ms) 
Rendered shared/_analytics (0.8ms) 
Completed in 4552ms (View: 3352, DB: 147) | 200 OK [http://localhost/family_index/surname_groups/31] 

Rubí 1,9

Rendered family_index/descendants/_fi_hover (0.3ms) 
Rendered family_index/descendants/_descendant (1.9ms) 
Rendered search/_search_div (0.1ms) 
Rendered family_index/descendants/_fi_hover (0.4ms) 
Rendered family_index/descendants/_descendant (2.0ms) 
Rendered search/_search_div (0.1ms) 
Rendered family_index/descendants/_fi_hover (0.3ms) 
Rendered family_index/descendants/_descendant (1.9ms) 
Rendered family_index/descendants/_fi_hover (0.3ms) 
Rendered family_index/descendants/_descendant (15.1ms) 
Rendered family_index/surname_groups/_pedigree (762.8ms) 
Rendered shared/_headers (2.6ms) 
Rendered shared/_new_messages (0.7ms) 
Rendered shared/_home_logo (0.9ms) 
Rendered shared/_login_box (3.6ms) 
Rendered shared/_navigation (7.3ms) 
Rendered shared/_flash_messages (0.7ms) 
Rendered shared/_footer (0.8ms) 
Rendered shared/_analytics (0.6ms) 
Completed in 5736ms (View: 942, DB: 128) | 200 OK [http://localhost/family_index/surname_groups/31] 

Parece que Ruby 1.9 es la prestación de los puntos de vista y el procesamiento de la base de datos más rápido, pero todavía está completando la solicitud más lento.

Rubí 1.8:

Completed in 4552ms (View: 3352, DB: 147) | 200 OK [http://localhost/family_index/surname_groups/31] 

Ruby 1.9:

Completed in 5736ms (View: 942, DB: 128) | 200 OK [http://localhost/family_index/surname_groups/31] 

actualización 10-26-2010

que he encontrado el cuello de botella en mi código. Viene de una línea que carga una tonelada de elementos de ActiveRecord utilizando las asociaciones cargadas de lazy-eager. El tiempo de base de datos es pequeño, pero supongo que toda la asignación de objetos está tomando un peaje. Aquí es mi asociación:

has_many :deep_branches, 
      :class_name => "FamilyIndex::Branch", 
      :include => { 
       :descendant => [:state, :county, {:wives => {:marriage => [:state,:county,:reference] }}, :reference, { 
       :children => [:state, :county, {:wives => {:marriage => [:state,:county,:reference] }}, :reference, { 
        :children => [:state, :county, {:wives => {:marriage => [:state,:county,:reference] }}, :reference, { 
        :children => [:state, :county, {:wives => {:marriage => [:state,:county,:reference] }}, :reference] # add marriages to this data 
        }] 
       }] 
       }] 
      } 

Sin hacer la carga ansiosa, la acción completa tarda unos 40 segundos en completarse, por lo que usar el: incluir da un aumento de aproximadamente 10 veces el rendimiento. Todavía estoy buscando una manera de acelerar esto. Quizás el almacenamiento en caché sea la única manera de hacerlo.

Answer 1

Por lo tanto, el área de mi pedido que tardaba más tiempo en procesarse era la carga masiva de datos a través de la carga lenta e impaciente de ActiveRecord (consulte la asociación incluida en la pregunta). No estoy lo suficientemente familiarizado con las partes internas de ActiveRecord 2.3.8, por lo que en última instancia no estoy seguro de lo que estaba causando la "lentitud".

Terminé haciendo mi propio tipo de ansioso cargando y obteniendo todos los registros de personas en una consulta, todos los estados en una consulta y otros objetos asociados que necesitaba, colocándolos en una Hash y luego uniéndolos en su árbol estructura.

Esto ha mejorado enormemente el rendimiento, reduciendo el tiempo de solicitud a 1-1.5 segundos. La mejora beneficia a la aplicación que se ejecuta en 1.8 y 1.9 y ahora mi aplicación es un poco más rápida ejecutándose en 1.9.

¡Gracias a todos por su ayuda!

Answer 2

Un área donde 1.9 puede ser más lento que 1.8 es el manejo de cadenas.

Desde 1.9 tiene correcta indexación de soporte Unicode o una rebanar una cadena Unicode con codificación puede tomar mucho más tiempo que en el 1,8 porque en 1,8 string[i] se acaba de devolver el i el octeto, mientras que en 1.9 se tiene que pasar por la cadena para encontrar el carácter i th.

Si realiza un gran manejo de cadenas y no necesita soporte Unicode adecuado, puede establecer la codificación en ASCII o posiblemente en binario, lo que debería acelerar el manejo de cadenas considerablemente.