Free 32 bit windows memory software for linux

Martian Memory project consists of a simple memory game.
Martian Memory is a simple memory game oriented to kids, featuring the Pachi el marcianos world characters.
The goal of the game is to pick up two identical chips from a board that contains 32. The game contains very nice visual effects, sounds, and very nice music composed by Jonne Valtonen.
Installing
Just do:
./configure
make
make install (as root).
Enhancements:
- Added the -f or --fullscreen switch.
- Changed some chips (removed bloody ones) the game is now "child safe".
- program exits if close window or press [F10].
- if two scores are equal they are ordered by minor time.
- time stops during a combo FX.
- the hiscores screen displays a "press right mouse button to return" sign.

Monkeys Memory is an implementation of the classic game of memory. Classic Game of Memory written in mono where you can play against other people (on the same computer, network game is not implemented jet) or against Computer (there is 2 type of computer player).

There is more level of game from tiny level to very big one.

MCP2510 Bit Timing Calculator project is a bit timing calculator for the MCP2510.

It is a bit timing calculator which is very easy to use.

All you have to do is to choose the baudrate and the oscilator-frequency.

Sure you can edit and change all setting. You will see a graphical bit timing diagram which show you your current options.

At the end you will get a detailed report of your choosen options. See an example here: mcp2510btn

HowTo

On the first step you have to choose your wished baudrate and the oscilator-frequency.

Second you will get a great table with all avaible baudrate for you oscilator-frequency. The are already choosen some baudrates if your baudrate equals with some on the table. Otherwise you have to select them manually, but you will get deviations to you choosen baudrate. You will the the deviation in percent at the right table.

When you are ready you can go forward to step three.
Here you have first to select your wanted Nominal Bit Time Screenshot 2 [Step 3]and then you can edit/change to values for the single segments of a bit timing.

Guarded Memory Move project gets handy when you have to study buffer overflows and you need to catch them together with a "good" stack image. When a stack overflow has been exploited, the back trace is already gone together with good information about parameters and local variables, that are of vital importance when trying to understand how the attacker is trying to work out the exploit. The GMM library uses dynamic function call interception to catch the most common functions that are used by attackers to exploit stack buffers.
The GMM library uses the LD_PRELOAD capability and offers two services to the user. First of all, it avoids buffer overflow to allow the attacker to execute shell-code on your machine. Second, in case where an exploit is detected, the stack content is saved and a segmentation fault is triggered. The resulting core dump will then have all the necessary information to debug the exploit and fix the software. Internally, the library insert itself between the application and the glibc library and intercept functions that might lead to buffer overflow exploits. Before calling the glibc core function, the GMM layer saves part of the stack frame above the caller to a temporary location in its frame.
It also stores the previous three return addresses in its local storage before calling the glibc core function. When the core function returns, the GMM code samples again the previously recorded return addresses and, if they differ, it restores the previously saved stack frame and issue a segmentation fault. This with a clean stack frame, so that it can be inspected with a debugger. While other solutions exist to detect buffer overflow exploits, like for example StackGuard and StackShield, those differs from GMM in many ways. They live as gcc patches and do require you to rebuild your application to use their functionalities. The good of this approach is that every single function is protected against buffer overflows.
The bad of this solution is that every single function is protected against buffer overflows. That is, performance regression on the whole application, even if this is not really a huge problem when hunting for buffer overflows. Another solution similar to GMM is LibSafe, but it does not save and restore the stack frame by making it unusable for debugging. But lets see how GMM differs from the above listed solutions. First of all, GMM works everywhere there are stack frames and the gcc and glibc duo. That means that it is not limited to i386 only. And now the real reason for the GMM existence.
Enhancements:
- GCCs __builtin_return_address and __builtin_frame_address seems to return garbage instead of NULL at the last frame. This release fixes the problem.

Bit::Vector is an efficient bit vector, set of integers and "big int" math library.

CLASS METHODS

Version

$version = Bit::Vector->Version();

Word_Bits
$bits = Bit::Vector->Word_Bits(); # bits in a machine word

Long_Bits
$bits = Bit::Vector->Long_Bits(); # bits in an unsigned long

new
$vector = Bit::Vector->new($bits); # bit vector constructor

@veclist = Bit::Vector->new($bits,$count);

new_Hex
$vector = Bit::Vector->new_Hex($bits,$string);

new_Bin
$vector = Bit::Vector->new_Bin($bits,$string);

new_Dec
$vector = Bit::Vector->new_Dec($bits,$string);

new_Enum
$vector = Bit::Vector->new_Enum($bits,$string);

Concat_List
$vector = Bit::Vector->Concat_List(@vectors);
OBJECT METHODS
new
$vec2 = $vec1->new($bits); # alternative call of constructor

@veclist = $vec->new($bits,$count);

Shadow
$vec2 = $vec1->Shadow(); # new vector, same size but empty

Clone
$vec2 = $vec1->Clone(); # new vector, exact duplicate

Concat
$vector = $vec1->Concat($vec2);

Concat_List
$vector = $vec1->Concat_List($vec2,$vec3,...);

Size
$bits = $vector->Size();

Resize
$vector->Resize($bits);
$vector->Resize($vector->Size()+5);
$vector->Resize($vector->Size()-5);

Copy
$vec2->Copy($vec1);

Empty
$vector->Empty();

Fill
$vector->Fill();

Flip
$vector->Flip();

Primes
$vector->Primes(); # Sieve of Erathostenes

Reverse
$vec2->Reverse($vec1);

Interval_Empty
$vector->Interval_Empty($min,$max);

Interval_Fill
$vector->Interval_Fill($min,$max);

Interval_Flip
$vector->Interval_Flip($min,$max);

Interval_Reverse
$vector->Interval_Reverse($min,$max);

Interval_Scan_inc
if (($min,$max) = $vector->Interval_Scan_inc($start))

Interval_Scan_dec
if (($min,$max) = $vector->Interval_Scan_dec($start))

Interval_Copy
$vec2->Interval_Copy($vec1,$offset2,$offset1,$length);

Interval_Substitute
$vec2->Interval_Substitute($vec1,$off2,$len2,$off1,$len1);

is_empty
if ($vector->is_empty())

is_full
if ($vector->is_full())

equal
if ($vec1->equal($vec2))

Lexicompare (unsigned)
if ($vec1->Lexicompare($vec2) == 0)
if ($vec1->Lexicompare($vec2) != 0)
if ($vec1->Lexicompare($vec2) < 0)
if ($vec1->Lexicompare($vec2) Lexicompare($vec2) > 0)
if ($vec1->Lexicompare($vec2) >= 0)

Compare (signed)
if ($vec1->Compare($vec2) == 0)
if ($vec1->Compare($vec2) != 0)
if ($vec1->Compare($vec2) < 0)
if ($vec1->Compare($vec2) Compare($vec2) > 0)
if ($vec1->Compare($vec2) >= 0)

to_Hex
$string = $vector->to_Hex();

from_Hex
$vector->from_Hex($string);

to_Bin
$string = $vector->to_Bin();

from_Bin
$vector->from_Bin($string);

to_Dec
$string = $vector->to_Dec();

from_Dec
$vector->from_Dec($string);

to_Enum
$string = $vector->to_Enum(); # e.g. "2,3,5-7,11,13-19"

from_Enum
$vector->from_Enum($string);

Bit_Off
$vector->Bit_Off($index);

Bit_On
$vector->Bit_On($index);

bit_flip
$bit = $vector->bit_flip($index);

bit_test
contains
$bit = $vector->bit_test($index);
$bit = $vector->contains($index);
if ($vector->bit_test($index))
if ($vector->contains($index))

Bit_Copy
$vector->Bit_Copy($index,$bit);

LSB (least significant bit)
$vector->LSB($bit);

MSB (most significant bit)
$vector->MSB($bit);

lsb (least significant bit)
$bit = $vector->lsb();

msb (most significant bit)
$bit = $vector->msb();

rotate_left
$carry = $vector->rotate_left();

rotate_right
$carry = $vector->rotate_right();

shift_left
$carry = $vector->shift_left($carry);

shift_right
$carry = $vector->shift_right($carry);

Move_Left
$vector->Move_Left($bits); # shift left "$bits" positions

Move_Right
$vector->Move_Right($bits); # shift right "$bits" positions

Insert
$vector->Insert($offset,$bits);

Delete
$vector->Delete($offset,$bits);

increment
$carry = $vector->increment();

decrement
$carry = $vector->decrement();

inc
$overflow = $vec2->inc($vec1);

dec
$overflow = $vec2->dec($vec1);

add
$carry = $vec3->add($vec1,$vec2,$carry);
($carry,$overflow) = $vec3->add($vec1,$vec2,$carry);

subtract
$carry = $vec3->subtract($vec1,$vec2,$carry);
($carry,$overflow) = $vec3->subtract($vec1,$vec2,$carry);

Neg
Negate
$vec2->Neg($vec1);
$vec2->Negate($vec1);

Abs
Absolute
$vec2->Abs($vec1);
$vec2->Absolute($vec1);

Sign
if ($vector->Sign() == 0)
if ($vector->Sign() != 0)
if ($vector->Sign() < 0)
if ($vector->Sign() Sign() > 0)
if ($vector->Sign() >= 0)

Multiply
$vec3->Multiply($vec1,$vec2);

Divide
$quot->Divide($vec1,$vec2,$rest);

GCD (Greatest Common Divisor)
$vecgcd->GCD($veca,$vecb);
$vecgcd->GCD($vecx,$vecy,$veca,$vecb);

Power
$vec3->Power($vec1,$vec2);

Block_Store
$vector->Block_Store($buffer);

Block_Read
$buffer = $vector->Block_Read();

Word_Size
$size = $vector->Word_Size(); # number of words in "$vector"

Word_Store
$vector->Word_Store($offset,$word);

Word_Read
$word = $vector->Word_Read($offset);

Word_List_Store
$vector->Word_List_Store(@words);

Word_List_Read
@words = $vector->Word_List_Read();

Word_Insert
$vector->Word_Insert($offset,$count);

Word_Delete
$vector->Word_Delete($offset,$count);

Chunk_Store
$vector->Chunk_Store($chunksize,$offset,$chunk);

Chunk_Read
$chunk = $vector->Chunk_Read($chunksize,$offset);

Chunk_List_Store
$vector->Chunk_List_Store($chunksize,@chunks);

Chunk_List_Read
@chunks = $vector->Chunk_List_Read($chunksize);

Index_List_Remove
$vector->Index_List_Remove(@indices);

Index_List_Store
$vector->Index_List_Store(@indices);

Index_List_Read
@indices = $vector->Index_List_Read();

Or
Union
$vec3->Or($vec1,$vec2);
$set3->Union($set1,$set2);

And
Intersection
$vec3->And($vec1,$vec2);
$set3->Intersection($set1,$set2);

AndNot
Difference
$vec3->AndNot($vec1,$vec2);
$set3->Difference($set1,$set2);

Xor
ExclusiveOr
$vec3->Xor($vec1,$vec2);
$set3->ExclusiveOr($set1,$set2);

Not
Complement
$vec2->Not($vec1);
$set2->Complement($set1);

subset
if ($set1->subset($set2)) # true if $set1 is subset of $set2

Norm
$norm = $set->Norm();
$norm = $set->Norm2();
$norm = $set->Norm3();

Min
$min = $set->Min();

Max
$max = $set->Max();

Multiplication
$matrix3->Multiplication($rows3,$cols3,
$matrix1,$rows1,$cols1,
$matrix2,$rows2,$cols2);

Product
$matrix3->Product($rows3,$cols3,
$matrix1,$rows1,$cols1,
$matrix2,$rows2,$cols2);

Closure
$matrix->Closure($rows,$cols);

Transpose
$matrix2->Transpose($rows2,$cols2,$matrix1,$rows1,$cols1);

DBPrim project is a library providing basic building blocks for creating in-memory databases.
Main features:
- Linked lists
- Hash tables with optional auto-resize
- Memory-efficient sparse matrices built on hash tables
- Red-black trees.

bandwidth project is an artificial benchmark for measuring memory bandwidth, useful for identifying a computers weak areas.
It tests several types of memory:
- Main memory read accesses
- Main memory write accesses
- Level 2 cache read accesses
- Level 2 cache write accesses
- Framebuffer read accesses
- Framebuffer write accesses
- String library routines
Enhancements:
- 64-bit support has been added.