Simulate an Old Klunker Computer

Disclaimer

This essay does not describe an existing computer program, just one that should exist. This essay is about a suggested student project in
Java programming. This essay gives a rough overview of how it might work. I have no source, object, specifications, file layouts or anything
else useful to implementing this project. Everything I have prepared to help you is right here.

This project outline is not like the artificial, tidy little problems you are spoon-fed in school, when all the facts you need are included, nothing extraneous is mentioned, the answer is
fully specified, along with hints to nudge you toward a single expected canonical solution. This project is much more like the real world of messy problems where it is up to you to fully the
define the end point, or a series of ever more difficult versions of this project and research the information yourself to solve them.

Everything I have to say to help you with this project is written below. I am not prepared to help you implement it; or give you any additional materials. I have too many
other projects of my own.

Though I am a programmer by profession, I don’t do people’s homework for them. That just robs them of an education.

You have my full permission to implement this project in any way you please and to keep all the profits from your endeavour.

Please do not email me about this project without reading the disclaimer above.

Introduction

People with older computers often complain that modern software does
not run well on them. This project creates a tool so that programmers with modern
machines can test the software they write to see how it will look and feel on older
machines.

How it Works

This program runs at high priority, sucking up resources, so that
the application under test is sufficiently starved that it appears to be running on an
old klunker. You can complete the illusion by temporarily reducing the screen resolution,
something outside the scope of this project.

How does it suck up resources?

Thread 1 has a tight CPU (Central Processing Unit) loop that alternates with short
sleeps.

Thread 2, which runs at sightly higher priority than thread 1, has a large virtual
memory that it randomly reads and writes, thus keeping the paging system busy. It too
alternates deliberate page faulting with short sleeps.

Calibration

You need some real world data on a variety of old klunkers. You need
to measure:

cpu cycles per minute, (or equivalently loop iterations per minute)

Page faults per second that can handled, (or equivalently random read/write
accesses to a very large array per minute).

To calibrate your resource sucker, you run a calibrating task at the same time and
tweak the resource sucker until the resources left to the calibrating task are the same
as measured on the real old klunker you are trying to simulate. I will leave the details
of efficient and automatic calibration to the reader.

Extensions

It is fairly easy to simulate a smaller screen just by changing the
resolution. Ideally you would want a way to also shrink the used portion of the screen as
well.

To simulate a slower Internet connection, you would have to write a replacement for
the standard Socket class that could be choked down, to let
through only so many bytes per second. Then you need to replace the standard Socket class with it in rt.jar. It would be just
like the standard Socket class with an extra static choke method for globally controlling
the choke on all external sockets. You don’t want to choke internal ones.

An conceptually easier, but less convenient way to implement it would be to write a
proxy relaying server than added delay. You then have to change all the socket numbers in
your application to do the tests.

Summary

The author of the program under test can then see just what range of
older computer will still run his program satisfactorily and can then make practical
minimum recommendations and might be encouraged to speed up the program. Further, it is
a tool for seeing where the bottlenecks are on these older machines.