Free 32 bit windows max ram software for linux

Booting Ubuntu To RAM is an article aims to document the process of creating a customized Ubuntu that loads an image from the hard disk to RAM, then boots an entire Ubuntu session out of RAM. It is intended for intermediate to advanced Ubuntu users who are familiar with the shell, and may have limited experience customizing the livecd (LiveCDCustomization) and shell scripting. We will customize a LiveCD and copy it to the hard drive, and make a few modifications to bootup scripts so that it copies to RAM via our good friend tmpfs.
WARNING: The author asserts that this procedure works for him, but cannot guarantee that this procedure works for anyone else. Although this procedure is meant to be 100% safe, it is feasible that there may be mistakes, or a chance of misunderstanding the instructions in a manner that causes loss of data. Please make a backup and do not attempt on mission critical systems. Read through this article thoroughly, and do not attempt if you do not comprehend or feel comfortable about any of the instructions!
CAUTION: I hope this is intuitively obvious, but Ill humor you and state it bluntly: Changes you make under the live session are NOT saved and WILL BE LOST when you reboot or shut down. Dont save anything important to the "home directory" and expect it to still be around! If you want to save data permanently, mount a permanent medium (such as your hard drive), plug in a thumbdrive, or use some network functionality built into Ubuntu to save your data to a non-volatile destination.
There are many cases where one would like to boot Ubuntu to RAM:
- Performance: The desktop performance is dramatically improved. A 400MB squashed filesystem in RAM, that holds 1200MB of data, is read back on a 1.6GHz Core Duo in about 3 seconds, including decompression time.
- Power, Noise, Durability: Although modern hard disks dont use much power compared to other system components, this may still be important for some. In laptops, hard disks are often the noisiest components, so this setup can reduce system noise. With the hard disk spun down, a laptop can potentially withstand greater shocks without damage.
- Abrupt poweroff: Since the hard disk is only momentarily used in read-only mode during boot, then never touched again, there are few or no negative consequences of an abrupt poweroff. If a system is used where power is inconsistent, or the system is regularly used in a context where fast shutoffs are required, this is very handy.
- Privacy: Anything you do in this session are lost when you reboot or power off. This is great for kiosks or other systems where permanent modification are not desired. (Note that by default the livecd user has full sudo access, so potentially a malicious user can still make permanent changes by mounting the hard drive and following this HOWTO)

AROS-Max is a AROS-based live-CD.

AROS Max is a pre-configured live bootable CD image, made to show off the best that AROS has to offer. It requires an AROS capable PC, your mileage may vary.

If you require help getting AROS-Max to run please ask for help on the Max area at the AROS-Exec messageboard, please do not email us directly with support problems!

AROS is a portable and free desktop operating system aiming at being compatible with AmigaOS 3.1, while improving on it in many areas. The source code is available under an open source license, which allows anyone to freely improve upon it.

The goals of the AROS project is it to create an OS which:

1. Is as compatible as possible with AmigaOS 3.1.
2. Can be ported to different kinds of hardware architectures and processors, such as x86, PowerPC, Alpha, Sparc, HPPA and other.
3. Should be binary compatible on Amiga and source compatible on any other hardware.
4. Can run as a standalone version which boots directly from hard disk and as an emulation which opens a window on an existing OS to develop software and run Amiga and native applications at the same time.
5. Improves upon the functionality of AmigaOS.

To reach this goal, we use a number of techniques. First of all, we make heavy use of the Internet. You can participate in our project even if you can write only one single OS function. The most current version of the source is accessible 24 hours per day and patches can be merged into it at any time. A small database with open tasks makes sure work is not duplicated.

Some time back in the year 1993, the situation for the Amiga looked somewhat worse than usual and some Amiga fans got together and discussed what should be done to increase the acceptance of our beloved machine. Immediately the main reason for the missing success of the Amiga became clear: it was propagation, or rather the lack thereof. The Amiga should get a more widespread basis to make it more attractive for everyone to use and to develop for. So plans were made to reach this goal. One of the plans was to fix the bugs of the AmigaOS, another was to make it an modern operating system. The AOS project was born.

But exactly what was a bug? And how should the bugs be fixed? What are the features a so-called modern OS must have? And how should they be implemented into the AmigaOS?

Two years later, people were still arguing about this and not even one line of code had been written (or at least no one had ever seen that code). Discussions were still of the pattern where someone stated that "we must have ..." and someone answered "read the old mails" or "this is impossible to do, because ..." which was shortly followed by "youre wrong because ..." and so on.

In the winter of 1995, Aaron Digulla got fed up with this situation and posted an RFC (request for comments) to the AOS mailing list in which I asked what the minimal common ground might be. Several options were given and the conclusion was that almost everyone would like to see an open OS which is compatible to AmigaOS 3.1 (kickstart 40.68) on which further discussions could be based upon to see what is possible and what is not.

So the work began and AROS was born.

The Wonder Shaper is a very special network shaper script with a lot of features. Works on Linux 2.4 & higher.

Goals

I attempted to create the holy grail:

* Maintain low latency for interfactive traffic at all times.

This means that downloading or uploading files should not disturb SSH or even telnet. These are the most important things, even 200ms latency is sluggish to work over.

* Allow surfing at reasonable speeds while up or downloading

Even though http is bulk traffic, other traffic should not drown it out too much.

* Make sure uploads dont harm downloads, and the other way around

This is a much observed phenomenon where upstream traffic simply destroys download speed. It turns out that all this is possible, at the cost of a tiny bit of bandwidth. The reason that uploads, downloads and ssh hurt eachother is the presence of large queues in many domestic access devices like cable or DSL modems.

Why it doesnt work well by default

ISPs know that they are benchmarked solely on how fast people can download. Besides available bandwidth, download speed is influenced heavily by packet loss, which seriously hampers TCP/IP performance. Large queues can help prevent packetloss, and speed up downloads. So ISPs configure large queues.

These large queues however damage interactivity. A keystroke must first travel the upstream queue, which may be seconds (!) long and go to your remote host. It is then displayed, which leads to a packet coming back, which must then traverse the downstream queue, located at your ISP, before it appears on your screen.

This HOWTO teaches you how to mangle and process the queue in many ways, but sadly, not all queues are accessible to us. The queue over at the ISP is completely off-limits, whereas the upstream queue probably lives inside your cable modem or DSL device. You may or may not be able to configure it. Most probably not.

So, what next? As we cant control either of those queues, they must be eliminated, and moved to your Linux router. Luckily this is possible.

Limit upload speed somewhat

By limiting our upload speed to slightly less than the truly available rate, no queues are built up in our modem. The queue is now moved to Linux.

Limit download speed

This is slightly trickier as we cant really influence how fast the internet ships us data. We can however drop packets that are coming in too fast, which causes TCP/IP to slow down to just the rate we want. Because we dont want to drop traffic unnecessarily, we configure a burst size we allow at higher speed.

Now, once we have done this, we have eliminated the downstream queue totally (except for short bursts), and gain the ability to manage the upstream queue with all the power Linux offers.

Let interactive traffic skip the queue

What remains to be done is to make sure interactive traffic jumps to the front of the upstream queue. To make sure that uploads dont hurt downloads, we also move ACK packets to the front of the queue. This is what normally causes the huge slowdown observed when generating bulk traffic both ways. The ACKnowledgements for downstream traffic must compete with upstream traffic, and get delayed in the process.

We also move other small packets to the front of the queue - this helps operating systems which do not set TOS bits, like everything from Microsoft.

Allow the user to specify low priority traffic (new in 1.1!)

Sometimes you may notice low priority OUTGOING traffic slowing down important traffic. In that case, the following options may help you:

NOPRIOHOSTSRC
Set this to hosts or netmasks in your network that should have low priority

NOPRIOHOSTDST
Set this to hosts or netmasks on the internet that should have low priority

NOPRIOPORTSRC
Set this to source ports that should have low priority. If you have an unimportant webserver on your traffic, set this to 80

NOPRIOPORTDST
Set this to destination ports that should have low priority.

See the start of wshaper and wshaper.htb

Results

If we do all this we get the following measurements using an excellent ADSL connection from xs4all in the Netherlands:

Baseline latency:
round-trip min/avg/max = 14.4/17.1/21.7 ms

Without traffic conditioner, while downloading:
round-trip min/avg/max = 560.9/573.6/586.4 ms

Without traffic conditioner, while uploading:
round-trip min/avg/max = 2041.4/2332.1/2427.6 ms

With conditioner, during 220kbit/s upload:
round-trip min/avg/max = 15.7/51.8/79.9 ms

With conditioner, during 850kbit/s download:
round-trip min/avg/max = 20.4/46.9/74.0 ms

When uploading, downloads proceed at ~80% of the available speed. Uploads at around 90%. Latency then jumps to 850 ms, still figuring out why.

What you can expect from this script depends a lot on your actual uplink speed. When uploading at full speed, there will always be a single packet ahead of your keystroke. That is the lower limit to the latency you can achieve - divide your MTU by your upstream speed to calculate. Typical values will be somewhat higher than that. Lower your MTU for better effects!

A small table:

Uplink speed | Expected latency due to upload
--------------------------------------------------
32 | 234ms
64 | 117ms
128 | 58ms
256 | 29ms

So to calculate your effective latency, take a baseline measurement (ping on an unloaded link), and look up the number in the table, and add it. That is about the best you can expect. This number comes from a calculation that assumes that your upstream keystroke will have at most half a full sized packet ahead of it.

This boils down to:

mtu * 0.5 * 10
-------------- + baseline_latency
kbit

The factor 10 is not quite correct but works well in practice.

Your kernel

If you run a recent distribution, everything should be ok. You need 2.4 with QoS options turned on.

If you compile your own kernel, it must have some options enabled. Most notably, in the Networking Options menu, QoS and/or Fair Queueing, turn at least CBQ, PRIO, SFQ, Ingress, Traffic Policing, QoS support, Rate Estimator, QoS classifier, U32 classifier, fwmark classifier.

In practice, I (and most distributions) just turn on everything.

The scripts

The script comes in two versions, one which works on standard kernels and is implemented using CBQ. The other one uses the excellent HTB qdisc which is not in the default kernel. The CBQ version is more tested than the HTB one!

See wshaper and wshaper.htb.

Tuning

These scripts need to know the real rate of your ISP connection. This is hard to determine upfront as different ISPs use different kinds of bits it appears. People report success using the following technique:

Estimate both your upstream and downstream at half the rate your ISP specifies. Now verify if the script is functioning - check interactivity while uploading and while downloading. This should deliver the latency as calculated above. If not, check if the script executed without errors.

Now slowly increase the upstream & downstream numbers in the script until the latency comes back. This way you can find optimum values for your connection. If you are happy, please report to me so I can make a list of numbers that work well. Please let me know which ISP you use and the name of your subscription, and its reputed specifications, so I can list you here and save others the trouble.

Installation

If you dial in, you can copy the script to /etc/ppp/ip-up.d and it will be run at each connect.

If you want to remove the shaper from an interface, run wshaper stop. To see status information, run wshaper status.

KNOWN PROBLEMS

If you get errors, add an -x to the first line, as follows:

#!/bin/bash -x

And retry. This will show you which line gives an error. Before contacting me, make sure that you are running a recent version of iproute!

Recent versions can be found at your Linux distributor, or if you prefer compiling, here:
ftp://ftp.inr.ac.ru/ip-routing/iproute2-current.tar.gz

Rescue Max is a Action Adventure in Space written in java.
Rescue! Max is a 2D space, real-time, action/strategy game in which you are in control of a ship that you fly around space, fighting enemies and making friends on your way.
Rescue! Maxs main objective is to rescue people from planets and take them to star bases.
Enhancements:
- made select enimies default
- added particle explosions
- redone SpaceObjects inheritance
- added wait curser when new mission is laoding
- Rescue theme: maximum energy to 9999 instead of 10000
- Rescue theme: added better romulan warbird
- Rescue theme: added original main ship
- Rescue max theme: less of those evil nutrals as default
- Fixed: make auto impulse and auto warp clear when the ship is killed (that is set as the destination)
- game ends when u get killed
- game does not start when u start the app

Riverdrums Load Balancer project is a no-frills, event-driven load balancer aimed at clarity and efficiency.

Compiling:

1. Install libevent
2. gcc -Wall -O2 -o rlb rlb.c -levent
Solaris:
a) cc -Wall -O2 -o rlb rlb.c -lnsl -lsocket -levent

Usage:

$ rlb -p port [-b addr] [-B addr] -h host:service[:max] [-h host:service[:max] ...] [-m max] [-t timeout] [-c check interval] [-s bufsize] [-n servers] [-f]

Simple Sound for Small Devices (libsssd) is a simple cross-platform audio library. Simple Sound for Small Devices is designed primarily for games on portable devices such as smart phones, PDAs, and hand-helds.
Simple Sound for Small Devices is designed as a very portable, cross-platform API for sound playback on small and embedded devices. Target platforms include smartphones, PDAs, Smart displays, webpads and embedded systems.
Target OSes include Linux (OSS/Free), Win32, WinCE/PPC/Smartphone, Symbian, and AmigaDE (both hosted and native). The library is biased toward real-time audio applications (like games), but is suitable for a wide array of other uses.
Installation:
To install the libsssd library, cd to the src direcotry and type make install
To make the demo applications, cd to the test directory and type make
Enhancements:
- Updated code to work with libsndfile 1.0.5
- Modularized each function for OSs that support tool libraries (AmigaDE)
- Added initAudio() and freeAudio() functions to allocate the control structure as different compilers may not pack the struct the same.
- Added support to init the audio player with different sample rates, bit depths, and channels (stereo, mono). Added support for user setting max number of playing channels and max number of cached samples at init time.
- fixed bug in player thread overflow functions (la,lb)

This is a project to create 64-bit virtual CPU, create a 64 bit assembler for the CPU and then port C to it, and then create scripts to port GNU/Linux to it.
The aim is to run 64-bit Linux on common 8/16/32 bit CPUs in applications where speed is not an issue.
Enhancements:
- Added C code intended tor a PIC Preliminary documentation More updates to Gambas program