Consejos de rendimiento para asp clásico?

Question

Hoy tuve la tarea de mejorar el rendimiento de una página ASP clásica. Reescribir el código en ASP.NET en este momento no es una opción, así que asumí el desafío de exprimir cada onza de rendimiento que puedo obtener de la página.

La página consiste en el "SELECCIONAR bla bla FROM bla" básico en un par de conjuntos de registros. Un ciclo while itera a través de esos conjuntos de registros y volcados <tr> <td> cadenas. Dentro del ciclo while hay un montón de condicionales y otras cosas. Hay 3 subrutinas que se llaman que usan variables globales (no variables locales pasadas como parámetros).

Así que nada realmente impactante ni nada. Antes de comenzar mi optimización, el ciclo tardó alrededor de 15 segundos en completarse. De los 15 segundos alrededor de 6 fueron tomados por la consulta SQL.

Después de cambiar algunas cosas, logré obtener alrededor de 7 segundos.

Las cosas que han cambiado en torno son:

• En vez de hacer SELECT *, que seleccionan sólo las columnas que necesitaba. La consulta bajó a un promedio de 4 segundos. Es una consulta bastante pesada con vistas dentro de las vistas.

• Eliminé todas las conmutaciones de contexto dentro del ciclo. Así que cambié cosas como <% = bla%> a Response.Write (bla).

• Las 3 subrutinas se definieron como funciones, pero se usaron como sub (sin resultado). Así que cambié las funciones a subs. ¿Eso ayuda?

Después de hacer mis cambios He encontrado que la mayoría de las veces estaba ocupado por una de las subrutinas. No he tenido tiempo suficiente hoy para cambiar la subrutina, aunque sí se compone de cosas como:

• Funciones de fecha: DATEADD, DATEDIFF
• Funciones de matriz: Ubound (RRA) y el índice de referencia: arr (I)
• funciones de cadena: a la izquierda, medio, derecho, inferior, reemplazar

Con cada llamada de búsqueda, dicha subrutina se ejecuta alrededor de 1600 veces.

¿Alguien por ahí tiene alguna experiencia con la optimización de páginas asp clásicas? ¿Tienes algún buen consejo para la optimización? Lo que estoy buscando es la mejora del código dentro de una declaración do ... loop.

Soy un experimentado desarrollador de ASP.NET y sé bastante sobre la mejora del rendimiento en ASP.NET. El ASP clásico usa un "motor" diferente, por lo que me preguntaba si alguien tiene alguna idea de cómo mejorar el rendimiento del ASP clásico.

Gracias!

M

PS: Sí sé que ASP clásico utiliza VBScript

Answer 1

GetRows Esto creará la velocidad que busca. Aquí están some other tips que he usado.

Answer 2

Con cada llamada de búsqueda, dicha subrutina se ejecuta alrededor de 1600 veces.

yo diría que es más o menos todo el problema, pero sin conocer los detalles de los datos devueltos de la consulta, lo que hace que la subrutina, y qué que hay que hacer 1600 veces de una página, que es Es difícil sugerir mucho para bajarlo.

Answer 3

Si realmente crees que el problema está en esa función, ¿por qué no pones el código aquí para que la gente pueda hacer sugerencias de optimización?

Answer 4

Experimenté que, en la mayoría de los casos, puede obtener rendimiento al usar un StringBuilder en ASP clásico. Hay un buen StringBuilder implementation para ASP clásico en el ajaxed library. Utiliza el .NET StringBuilder. Eso es bastante fresco y fácil de usar:

<% 
set output = new StringBuilder 
do 
    output("some output") 
loop 
response.write(output.toString()) 
%> 

Yo recomiendo usar la biblioteca ajaxed si necesita hacer algunos ajustes. Se configura rápidamente y le ofrece muchas herramientas para ASP clásico. P.ej. Tal vez también podría obtener algún rendimiento cuando use AJAX (o al menos la impresión de rendimiento).

Answer 5

Estoy marcando la respuesta de MrChrister como la respuesta a mi pregunta "¿Tiene algún buen consejo para la optimización?". Los consejos son buenos y logró acelerar el script en 2 segundos.

Descubrí finalmente lo que estaba haciendo el script lento. En el ciclo while el programador estaba haciendo Filter (Array) mucho. Básicamente estaba usando Filter (Array) para buscar pares clave/valor.

Así que la solución final fue cambiar el código de Filtro (Array) a usar el objeto "Scripting.Dictionary". Aceleró el código por un factor de 12.

Gracias por todas sus respuestas.

M

Answer 6

Al ver que esto es una pregunta popular que he decidido explicar lo que hice hace 3 años que aceleró la secuencia de comandos ASP.

La secuencia de comandos original hizo un uso intensivo de arreglos redimensionables para almacenar pares clave-valor, por lo que modifiqué ese código para usar Scriting.Dictionary. Ejemplo:

Dim myDictionary 
Set myDictionary = Createobject("Scripting.Dictionary") 
myDictionary.item("key") = "value" 

Eso es mucho más rápido que las matrices de tamaño variable.

Otro gran cambio es la concatenación de cadenas. El guión original estaba lleno de:

S = "" 
S = S & "First line<br />" 
S = S & "Second line<br />" 
S = S & "Third line line<br />" 
Response.Write(S) 

modifiqué esto:

Response.Write("First line<br />") 
Response.Write("Second line<br />") 
Response.Write("Third line<br />") 

Esto marcó una gran diferencia. La concatenación de cadenas es un gran cuello de botella porque la cadena se descarta y luego se reinicializa.

Otra opción es:

S = "First line<br />" & _ 
     "Second line<br />" & _ 
     "Third line line<br />" 
Response.Write(S) 

Esto también es un buen consejo para ASP.NET: Utilice un StringBuilder en lugar de la concatenación de cadenas.

Otro cambio importante es el cambio de contexto. El código original estaba lleno de:

<table> 
    <tr> 
     <td><%= rs("Col1") %></td> 
     <td><%= rs("Col2") %></td> 
     <td><%= rs("Col2") %></td> 
    </tr> 
</table> 

3 El contexto cambia tome mucho tiempo por lo que he modificado a esto:

<% 
Response.Write("<table>") 
Response.Write("<tr>") 
Response.Write("<td>") 
Response.Write(rs("Col1")) 
Response.Write("</td>") 
Response.Write("</tr>") 
Response.Write("<tr>") 
Response.Write("<td>") 
Response.Write(rs("Col2")) 
Response.Write("</td>") 
Response.Write("</tr>") 
Response.Write("<tr>") 
Response.Write("<td>") 
Response.Write(rs("Col3")) 
Response.Write("</td>") 
Response.Write("</tr>") 
Response.Write("</table>") 
%> 

Si el código es muy redundante, pero tiene un mejor rendimiento.

Otra pequeña modificación (que en realidad es un truco sucio) es utilizar CON (NOLOCK) en las consultas SQL:

conn.Query("SELECT * FROM MyTable WITH (NOLOCK) LEFT JOIN AnotherTable WITH (NOLOCK) ON MyTable.Id = AnotherTable.Id") 

se hace una diferencia.

Finalmente, no sé si eso ayuda mucho, pero había un montón de código de copiado que refactoricé a las funciones de limpieza.

Espero que a las personas que encuentren este tema les resulten útiles estos consejos.