Skip to contentSkip to conversation

performance-improvement-of-serial-console-via-virtual.patch added to -mm tree

DISCUSSION Taku Izumi 3 participants 8 messages Sep 8, 2005 – Sep 15, 2005 2 messages not in the archive

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

Taku Izumi

author
#2 lore raw

Dear Russell:

Quoted 5 lines

I don't think we want this. With early serial console, tx_loadsz is not guaranteed to be initialised, and may in fact be zero.

Plus there's no guarantee that the FIFOs will actually be enabled, so I think it's better that this patch doesn't go to mainline.

Our server has a virtual serial port, but its performance seems to be poor. It takes 10 seconds to output 4000 characters (from kernel) to serial console. By applying my patch, its peformance could be improved. ( 0.4 seconds / 4000 characters output), so I think it is useful to use FIFO at serial8250_console_write function like transmit_chars function. Where should I correct in order to use FIFO?

Taku Izumi <[email protected]>

#3 lore raw
Quoted 6 lines · Taku Izumi
Quoted 5 lines

I don't think we want this. With early serial console, tx_loadsz is not guaranteed to be initialised, and may in fact be zero.

Plus there's no guarantee that the FIFOs will actually be enabled, so I think it's better that this patch doesn't go to mainline.

Quoted 6 lines

Our server has a virtual serial port, but its performance seems to be poor. It takes 10 seconds to output 4000 characters (from kernel) to serial console. By applying my patch, its peformance could be improved. ( 0.4 seconds / 4000 characters output), so I think it is useful to use FIFO at serial8250_console_write function like transmit_chars function. Where should I correct in order to use FIFO?

The problem is that we don't know:

* if there is a FIFO
* what size the FIFO is
* if it has been initialised
* how much data is already contained in the FIFO

So we can't really blindly initialise the FIFO in the console write method. Neither can we initialise it in the console setup. If we could initialise it, we can't blindly load 16 bytes into the FIFO at a time.

I don't think it's technically practical to use the FIFO for the console and still have a reliable serial port.

Signature · 3 lines
Russell King
 Linux kernel    2.6 ARM Linux   - http://www.arm.linux.org.uk/
 maintainer of:  2.6 Serial core
#4 lore raw

Hi Russel,

I am working with Taku,

Quoted 14 lines · Taku Izumi
Quoted 6 lines
Quoted 5 lines

I don't think we want this. With early serial console, tx_loadsz is not guaranteed to be initialised, and may in fact be zero.

Plus there's no guarantee that the FIFOs will actually be enabled, so I think it's better that this patch doesn't go to mainline.

Quoted 6 lines

Our server has a virtual serial port, but its performance seems to be poor. It takes 10 seconds to output 4000 characters (from kernel) to serial console. By applying my patch, its peformance could be improved. ( 0.4 seconds / 4000 characters output), so I think it is useful to use FIFO at serial8250_console_write function like transmit_chars function. Where should I correct in order to use FIFO?

Quoted 4 lines

The problem is that we don't know:

* if there is a FIFO
* what size the FIFO is

I understand tx_loadsz is practical TX FIFO size. If there is no FIFO, tx_loadsz becomes 1. Is it wrong?

- tx_loadsz is properly initilized in autoconfig().
- FIFO is enabled in serial8250_clear_fifo() called from autoconfig(), if FIFO exist.
- autoconfig() is called from serial8250_isa_init_ports().
- serial8250_isa_init_ports() is called from serial8250_console_init() etc.

I can't find the problem you are pointing out.

Quoted 2 lines

* if it has been initialised
* how much data is already contained in the FIFO

Right, we can't know how many byte exist in the FIFO. So this patch is waiting the FIFO becomes empty at first by calling "wait_for_xmitr(up)".
(This is the same logic with original.)

After TX FIFO become empty, we can decide the available TX FIFO depth by up->tx_loadsize.

Quoted 31 lines
       for (i = 0; i < count; ) {
               int     fifo;

               wait_for_xmitr(up);
               fifo = up->tx_loadsz;
               /*
                *      Send the character out using FIFO.
                *      If a LF, also do CR...
                */
               do {
                       serial_out(up, UART_TX, *s);
                       fifo--;
                       if (*s == 10) {
                               if (fifo > 0) {
                                       serial_out(up, UART_TX, 13);
                                       fifo--;
                               } else {
                                       /* No room to add CR */
                                       wait_for_xmitr(up);
                                       fifo = up->tx_loadsz;
                                       serial_out(up, UART_TX, 13);
                                       fifo--;
                               }
                       }
                       i++;
                       s++;
               } while (fifo > 0 && i < count );
       }
Quoted 13 lines

So we can't really blindly initialise the FIFO in the console write method. Neither can we initialise it in the console setup. If we could initialise it, we can't blindly load 16 bytes into the FIFO at a time.

I don't think it's technically practical to use the FIFO for the console and still have a reliable serial port.

Signature · 4 lines
Russell King
Linux kernel    2.6 ARM Linux   - http://www.arm.linux.org.uk/
maintainer of:  2.6 Serial core
-

Best regards,
Hironobu Ishii

#5 lore raw
Quoted 27 lines · Hironobu Ishii

Hi Russel,

I am working with Taku,

Quoted 14 lines · Taku Izumi
Quoted 6 lines
Quoted 5 lines

I don't think we want this. With early serial console, tx_loadsz is not guaranteed to be initialised, and may in fact be zero.

Plus there's no guarantee that the FIFOs will actually be enabled, so I think it's better that this patch doesn't go to mainline.

Quoted 6 lines

Our server has a virtual serial port, but its performance seems to be poor. It takes 10 seconds to output 4000 characters (from kernel) to serial console. By applying my patch, its peformance could be improved. ( 0.4 seconds / 4000 characters output), so I think it is useful to use FIFO at serial8250_console_write function like transmit_chars function. Where should I correct in order to use FIFO?

Quoted 4 lines

The problem is that we don't know:

* if there is a FIFO
* what size the FIFO is

I understand tx_loadsz is practical TX FIFO size. If there is no FIFO, tx_loadsz becomes 1.
Is it wrong?

Quoted 7 lines

- tx_loadsz is properly initilized in autoconfig().
- FIFO is enabled in serial8250_clear_fifo() called from autoconfig(), if FIFO exist.
- autoconfig() is called from serial8250_isa_init_ports().
- serial8250_isa_init_ports() is called from serial8250_console_init() etc.

I can't find the problem you are pointing out.

autoconfig() is _not_ called from serial8250_isa_init_ports().

The problem is that the console write method may be called prior to autoconfig() being run for the port in question, so tx_loadsz may be uninitialised.

Quoted 10 lines
Quoted 2 lines

* if it has been initialised
* how much data is already contained in the FIFO

Right, we can't know how many byte exist in the FIFO. So this patch is waiting the FIFO becomes empty at first by calling "wait_for_xmitr(up)".
(This is the same logic with original.)

After TX FIFO become empty, we can decide the available TX FIFO depth by up->tx_loadsize.

Only if you ignore the fact that tx_loadsz may not be initialised.

The only things which the console code can rely on being initialised is the port address description (iobase / membase / iotype / regshift), the flow control (UPF_CONS_FLOW) in flags, and in the case of Xscale systems, the capabilities. Everything else will be in an indeterminent state as far as the serial console code is concerned, and therefore can not be relied upon.

Signature · 3 lines
Russell King
 Linux kernel    2.6 ARM Linux   - http://www.arm.linux.org.uk/
 maintainer of:  2.6 Serial core
#6 lore raw
Quoted 6 lines · Russell King

The only things which the console code can rely on being initialised is the port address description (iobase / membase / iotype / regshift), the flow control (UPF_CONS_FLOW) in flags, and in the case of Xscale systems, the capabilities. Everything else will be in an indeterminent state as far as the serial console code is concerned, and therefore can not be relied upon.

Additionally, once all architectures convert to initialising their serial ports via platform devices (which means include/asm-*/serial.h becomes essentially empty) and we eliminate serial8250_console_init(), the 8250 console code can start assuming that more of the uart_port structure will be initialised.

At that point, we can start to think about using FIFOs for the console.

However, this is an exercise for architecture maintainers to do who in theory know the requirements for their platforms. So far I've seen little progress on this though.

Signature · 3 lines
Russell King
 Linux kernel    2.6 ARM Linux   - http://www.arm.linux.org.uk/
 maintainer of:  2.6 Serial core
#7 lore raw

Hi Russell,

Quoted 8 lines

Additionally, once all architectures convert to initialising their serial ports via platform devices (which means include/asm-*/serial.h becomes essentially empty) and we eliminate serial8250_console_init(), the 8250 console code can start assuming that more of the uart_port structure will be initialised.

At that point, we can start to think about using FIFOs for the console.

Thank you for FIFO consideration.

me> Before initialization, does tx_loadsz left 0?
me> If so, we can easily solve the problem:

I confirmed this assumption is OK in current code, because seiral8250_ports[] is static variable.

We will release revised patch later,
please apply our patch until your serial driver re-organization completes.

Thank you.
Hironobu Ishii

author
#8 lore raw

Dear Russel:

I change my patch based on the result of discussion.

The change is as follows:

- add a member to uart_8250_port structure in order to check if FIFO is enable or not.
- use FIFO at serial8250_console_write function only when FIFO is enable.

I tested my patch on i386 and ia64 architecture.

drivers/serial/8250.c +34 -9
diff -urNp linux-2.6.14-rc1.org/drivers/serial/8250.c linux-2.6.14-rc1/drivers/serial/8250.c
@@ -128,6 +128,7 @@ struct uart_8250_port {
 	unsigned char		mcr_mask;	/* mask of user bits */
 	unsigned char		mcr_force;	/* mask of forced bits */
 	unsigned char		lsr_break_flag;
+	unsigned char		fcr;
 
 	/*
 	 * We provide a per-port pm hook.
@@ -332,6 +333,7 @@ static unsigned int serial_icr_read(stru
 static inline void serial8250_clear_fifos(struct uart_8250_port *p)
 {
 	if (p->capabilities & UART_CAP_FIFO) {
+		p->fcr = 0;
 		serial_outp(p, UART_FCR, UART_FCR_ENABLE_FIFO);
 		serial_outp(p, UART_FCR, UART_FCR_ENABLE_FIFO |
 			       UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
@@ -1809,8 +1811,10 @@ serial8250_set_termios(struct uart_port 
 	 * LCR DLAB must be set to enable 64-byte FIFO mode. If the FCR
 	 * is written without DLAB set, this mode will be disabled.
 	 */
-	if (up->port.type == PORT_16750)
+	if (up->port.type == PORT_16750) {
 		serial_outp(up, UART_FCR, fcr);
+		up->fcr = fcr;
+	}
 
 	serial_outp(up, UART_LCR, cval);		/* reset DLAB */
 	up->lcr = cval;					/* Save LCR */
@@ -1820,6 +1824,7 @@ serial8250_set_termios(struct uart_port 
 			serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
 		}
 		serial_outp(up, UART_FCR, fcr);		/* set fcr */
+		up->fcr = fcr;
 	}
 	serial8250_set_mctrl(&up->port, up->port.mctrl);
 	spin_unlock_irqrestore(&up->port.lock, flags);
@@ -2140,6 +2145,7 @@ serial8250_console_write(struct console 
 	struct uart_8250_port *up = &serial8250_ports[co->index];
 	unsigned int ier;
 	int i;
+	int tx_loadsz;
 
 	/*
 	 *	First save the UER then disable the interrupts
@@ -2152,20 +2158,39 @@ serial8250_console_write(struct console 
 		serial_out(up, UART_IER, 0);
 
 	/*
+	 *	Check whether FIFO is enabled
+	 */ 
+	tx_loadsz = (up->fcr & UART_FCR_ENABLE_FIFO ? up->tx_loadsz : 1);
+	/*
 	 *	Now, do each character
 	 */
-	for (i = 0; i < count; i++, s++) {
-		wait_for_xmitr(up);
+	for (i = 0; i < count; ) {
+		int	fifo;
 
+		wait_for_xmitr(up);
+		fifo = tx_loadsz;
 		/*
-		 *	Send the character out.
+		 *	Send the character out using FIFO.
 		 *	If a LF, also do CR...
 		 */
-		serial_out(up, UART_TX, *s);
-		if (*s == 10) {
-			wait_for_xmitr(up);
-			serial_out(up, UART_TX, 13);
-		}
+		do {
+			serial_out(up, UART_TX, *s);
+			fifo--;
+			if (*s == 10) {
+				if (fifo > 0) {
+					serial_out(up, UART_TX, 13);
+					fifo--;
+				} else {
+					/* No room to add CR */
+					wait_for_xmitr(up);
+					fifo = tx_loadsz;
+					serial_out(up, UART_TX, 13);
+					fifo--;
+				}
+			}
+			i++;
+			s++;
+		} while (fifo > 0 && i < count);
 	}
 
 	/*
#9 lore raw
In reply to Russell King

Hi Russel,

Quoted 4 lines

The problem is that the console write method may be called prior to autoconfig() being run for the port in question, so tx_loadsz may be uninitialised.

Thank you for explanation.

Quoted 11 lines
Quoted 9 lines
Quoted 2 lines

* if it has been initialised
* how much data is already contained in the FIFO

Right, we can't know how many byte exist in the FIFO. So this patch is waiting the FIFO becomes empty at first by calling "wait_for_xmitr(up)".
(This is the same logic with original.)

After TX FIFO become empty, we can decide the available TX FIFO depth by up->tx_loadsize.

Only if you ignore the fact that tx_loadsz may not be initialised.

OK.
Before initialization, does tx_loadsz left 0?
If so, we can easily solve the problem:

  tx_loadsz = (up->tx_loadsz ? up->tx_loadsz : 1); <-----
  for (i = 0; i < count; ) {
          int     fifo;
          wait_for_xmitr(up);
          fifo = tx_loadsz;        <------
           .
           .
           .

Best regards,
Hironobu Ishii