The circles representing different answer choices on the answer sheet of a test that will be machine-graded, such as a standardized test.

In the novels Signal to Noise and A Signal Shattered by Eric S. Nylund, bubbles are self-contained full-immersion virtual reality workstations that send signals to devices implanted in the user's cerebral cortex through extremely precise electromagnetic induction fields. The only drawback of this -- and it's a doozy -- is that stray magnetic fields leak through the user's implant's shielding unless one is in a already heavily shielded environment, causing painful feedback and sensory overload. In the novels, most implanted persons go about with silly-looking metal helmets on their heads when outside these shielded areas, so that they don't suddenly walk into a pulse of EM that fries their brains.

Bubbles provide photorealistic virtual environments in which every sensation is mimiced perfectly, where users of other bubbles can interact, perform simulations and control tools. Nearly every high-end electronic device can be controlled from a bubble.

The most interesting thing Nylund's bubbles, though, are the intuition-enhancing features. Bubbles literally help you think better, by taking cues from your subconscious mind and converting them into metaphors that you can perceive in the virtual reality, helping you solidify hunches and make guesses more quickly. This also facillitates human communication, as mood and opinion are expressed by alterations in the bubble environment. Nylund's descriptions of bubble use are fascinating and poetic.

I want a bubble.

Bubble is played by Jane Horrocks in Absolutely Fabulous. She is Edina Monsoon's hopeless assistant and spends most of her time looking very confused by Edina's orders and requests. Not that Edina is the best at running a PR firm but even so, Bubble only ever seems to make things worse. On the few occassions when Edina is actually organised and asks Bubble to do a list of things, she has a tendency to forget to do most of them. However from time to time she does what is asked of her.

Bubble is not completely stupid - more ditsy, living in a slightly different world from the rest of us. She speaks fluent French which provides a humorous ending to a feature-length episode. Deciding to go to France and booking accommodation at a chateau, the group arrive at a French cottage in the dead of night. Edina thinks is where they're supposed to stay but on several occasions a local Frenchman tries to redirect them to the chateau. Neither Edina nor Patsy speak French, so they shoo him off. At the end Bubble talks to him and finds out that the chateau was only 5km down the road. But of course, no one would have thought to ask Bubble if she spoke French....

Another memorable incident was when she turned up to Edina's house with a "lap-dog" when she had been asked to buy a "lap-top". She tries hard and seems to stop the company collapse around Edina's ears but never seems to have a single bright thought in her head. She is also quite insensitive. When Edina fusses on how to lose weight, Bubble points out that "I just cannot put on weight" and keeps asserting that point over and over, much to Edina's annoyance.

Reggae keyboard players often play a variation of the skank that is known as the bubble. It is a skank with an extra sound before and after the skank that creates a triplet feel.

Of all the bits of jargon and terminology used in computer architecture, the term 'bubble' is one of the more whimsical, as well as being wonderfully descriptive and almost poetically succinct. The word is used to refer to the phenomenon of idle stages in a processor pipeline, and the name, by analogy, tells us a little about the behaviour of such idle units.

Let's illustrate this with a simple example. Consider a simple 5-stage RISC pipeline, like an early MIPS processor, or the ARM processor in your mobile phone, and a simple program fragment:


Fetch -> Decode -> ALU -> Memory -> Writeback

...and our program fragment, a simple implementation of the strlen() function:

        mov     r1, r0          ; save pointer
        mov     r0, #0          ; initialise count
loop:   ldrb    r2, [r1, #1]!   ; load byte from memory at r1, increment r1.
        cmp     r2, #0          ; compare byte with '\0'.
        addne   r0, r0, #1      ; increment string length
        bne     loop            ; loop back round if it's not
        mov     pc, lr          ; return from function

(This is obviously some handwritten assembly code rather than the output of a compiler. You can tell because of the comments, and because any compiler worth its salt would have eliminated that 'addne' in the loop in favour of a subtraction outside the loop using the exit value of the induction variable...)

Instructions flow through the pipeline in the obvious order: they're fetched from memory in the Fetch stage. They're decoded in the Decode stage, where the processor works out what else it needs to do in order to execute the instruction. In the ALU stage, simple arithmetic instructions are executed, and the addresses for memory instructions are calculated. In the Memory stage, loads and stores access memory using the addresses they previously calculated in the ALU, and in Writeback, assuming any memory accesses went off without a hitch, the results of the instruction are written back to the register file.

So the instruction sequence above can execute, with the help of a a little register bypassing without much problem for the first few cycles, each instruction following hot on the heels of the previous one, and each pipeline stage busy doing something useful in every cycle. Until, that is, the pipeline hits the following state:

Fetch -> Decode -> ALU  -> Memory -> Writeback
addne    cmp       ldrb    add       mov r0, #0

What happens in the next cycle? At first glance it seems obvious: the add moves to the Writeback stage, the ldrb moves into the Memory stage, and the cmp instruction moves to the ALU. But there's a problem. The cmp instruction needs the value loaded to r0 by the ldrb instruction. But the load instruction hasn't yet entered the Memory stage. The value loaded from memory will only be available at the end of the next cycle, but it's needed as an input to the ALU at the beginning of the cycle.

So the comparison instruction must wait in Decode until the load instruction completes its memory access, moving into the Memory stage.

So during the next cycle, the pipeline looks a little like this:

Fetch -> Decode -> ALU  -> Memory -> Writeback
addne    cmp      (empty)  ldrb      add

During this cycle, the ALU pipeline stage is idle waiting on the result from the load in the Memory stage. It's a gap in an otherwise full, efficiently-operating pipeline.

In the next cycle, though, the memory result is available, and the pipeline can go about its business. Every instruction is free to move on to the next pipe stage:

Fetch -> Decode -> ALU  -> Memory -> Writeback
bne      addne     cmp     (empty)   ldrb

But what's this? Not only have the instructions moved on, but so has the idle pipeline stage. Since there was no instruction in the ALU stage in the last cycle, there is now no instruction to move into the Memory stage. It's an idle pipeline stage, but it moves through the pipeline in a way that makes it look almost like a real instruction.

It's this behaviour that leads us to call these phenomena 'bubbles'. Much like bubbles in a narrow pipe, these gaps move along the pipeline, reducing the efficiency of the processor.

Pipeline bubbles occur any time a pipeline must stall some instruction while waiting for the results of some other instruction, or when a branch is mispredicted, or when cache misses hold things up. In simpler pipelines, they'll also occur on write-after-write and write-after-read dependencies, and things like that.

So! Next time you think your computer is going too slow, you know what to do: check it for bubbles!

Bub"ble (?), n. [Cf. D. bobbel, Dan. boble, Sw. bubbla. Cf. Blob, n.]


A thin film of liquid inflated with air or gas; as, a soap bubble; bubbles on the surface of a river.

Beads of sweat have stood upon thy brow, Like bubbles in a late disturbed stream. Shak.


A small quantity of air or gas within a liquid body; as, bubbles rising in champagne or aerated waters.


A globule of air, or globular vacuum, in a transparent solid; as, bubbles in window glass, or in a lens.


A small, hollow, floating bead or globe, formerly used for testing the strength of spirits.


The globule of air in the spirit tube of a level.


Anything that wants firmness or solidity; that which is more specious than real; a false show; a cheat or fraud; a delusive scheme; an empty project; a dishonest speculation; as, the South Sea bubble.

Then a soldier . . . Seeking the bubble reputation Even in the cannon's mouth. Shak.


A person deceived by an empty project; a gull.

[Obs.] "Ganny's a cheat, and I'm a bubble."



© Webster 1913.

Bub"ble, v. i. [imp. & p. p. Bubbled (); p. pr. & vb. n. Bubbling ().] [Cf. D. bobbelen, Dan. boble. See Bubble, n.]


To rise in bubbles, as liquids when boiling or agitated; to contain bubbles.

The milk that bubbled in the pail. Tennyson.


To run with a gurdling noise, as if forming bubbles; as, a bubbling stream.



To sing with a gurgling or warbling sound.

At mine ear Bubbled the nightingale and heeded not. Tennyson.


© Webster 1913.

Log in or register to write something here or to contact authors.