Solution
First identify the state the printer was in at the time the error was displayed. For example, an action
taken when the printer is drying can produce an error, whereas the same action when the printer is
doing something else (or is idle) may not produce any error.
When you have identified the steps that caused the error, proceed as follows.
1. Escalate the issue to the GBU through the GCC in order to have it corrected in the firmware.
2. Recommend to customers that they try to avoid the same steps to avoid the error.
3. If the conditions that cause the error are in the customer’s regular workflow, try to identify a
different way of achieving the same result.
Random SE 79:04 (memory leaks and concurrence issues)
Some 79:04 errors can happen randomly when the printer is heavily used. However, it’s impossible to
find a single set of conditions that reproduce the problem. It just happens from time to time, without a
defined pattern.
These random 79:04 errors can have two different types of root causes.
●
Memory leaks: Before a program is executed, it allocates the memory it will need. After the
execution is complete, the allocated memory is freed to be used by other programs. If the
allocation or the release of the memory are not properly programmed, every time the program is
executed some memory will be incorrectly labelled (either as used or as free). This is known as a
memory leak. When a program with a memory leak is executed a lot, the memory becomes
progressively full (since it is not properly freed). When the leak becomes too big, the printer is left
‘out of memory’ to execute new processes and a 79:04 is triggered.
●
Concurrence issues: There are certain resources that can be accessed by multiple programs or
by multiple executions of the same program (what is known as multiple threads). Access to these
resources must be correctly controlled to prevent unexpected behavior. Issues caused by incorrect
control of these resources are concurrence issues.
For example, imagine that there is a counter that controls the communication between the Jetdirect card
and the printer’s firmware. Whenever a new packet of information is sent by the Jetdirect card to the
printer, the counter increases. When the printer receives the packet and processes it correctly, the
counter decreases. Another process checks the counter from time to time to see its value and draw
conclusions from it. If the counter is near 0, it means that the printer is processing correctly, and if it
grows too large, it may mean that there is a bottleneck somewhere and maybe the Jetdirect card
throughput is decreased to control its speed to the printer. However, if the access to this counter is not
properly controlled, undesirable effects may happen: in a real environment, a Jetdirect card processes
thousands of information packets per second, so this counter is updated frequently, both by the Jetdirect
and the printer. If at a certain point the Jetdirect card and the printer try to access the counter at the
same time and the code is not prepared to handle this, it may happen that the Jetdirect cannot increase
the counter because the printer is writing to it, and what’s worse, it does not realize this fact. If this
happens a few times each second, it may happen that the counter is decreasing faster than it’s
increasing and that at a certain point it has a negative value. And then, what will the process that is
checking this counter do? Most likely, the process will not be prepared to react to a negative value and
will launch an exception that will trigger a 79:04 system error.
ENWW
How to troubleshoot the 79:04 system error
33
To Next Page
Loading...