C

big.c (schnell Platte füllen)

#include <stdio.h>
#include <stdlib.h>

int main(int count, char** arg){
  FILE* file = fopen("big.data", "w");
  int size = 0x10000 * 128;
  void* data = calloc(size, 1);
  int mByte = 0;
  while (fwrite(data, size, 1, file) > 0){
    mByte += size / 1024 / 1024;
    printf("%d MByte\n", mByte);
  }
  return 0;
}

CPU-Benchmark hamamips.c

#include "stdio.h"
#include "stdlib.h"
#include "time.h"
typedef unsigned long seed_t;
#define DEFINE_VARS(seed, x, y, z, c) seed_t 	seed = 0x20111958UL; \
	seed_t x = 0x33221122UL; \
	seed_t y = 0x73829382UL; \
	seed_t z = 0xabcdef07UL; \
	seed_t c = 0
#define next(seed, x, y, z, c) \
	do { \
		x = x * 0x20111957 + 0x11121989; \
		y ^= y << 13; \
		y ^= y >> 17; \
		y ^= y << 5; \
		seed_t t = 698769069UL * z + c; \
		c = t << 31; \
		z = t; \
		seed = x + y + z; \
	} while (0)
seed_t calcRandom(int millions){
	DEFINE_VARS(seed, x, y, z, c);
	seed_t rc = 0;
	while (millions-- > 0){
		int ix2 = 1000000;
		while(ix2-- > 0){
			next(seed, x, y, z, c);
			rc += seed;
		}
	}
	return rc;
}
int memSpeed(int megaBytes, int rounds){
        clock_t start = clock();
        int ix, ix2, round;
        double** buffers = (double**) malloc(megaBytes * 1024 * 1024);
        int bufferEntries = 1024*1024/sizeof(double);
        for (ix = 0; ix < megaBytes; ix++){
                buffers[ix] = (double*) malloc(sizeof(double)*bufferEntries);
                for (ix2 = 0; ix2 < bufferEntries; ix2++)
                        buffers[ix][ix2] = ix2*ix;
        }
        for (round = 0; round < rounds; round++)
                for (ix2 = bufferEntries - 1; ix2 >= 0; ix2--)
                        for (ix = megaBytes - 1; ix >= 0; ix--)
                                buffers[ix][ix2] += 1;
        clock_t duration = clock() - start;
        printf("%.3f MemMips %.3f sec %d MiBytes %d rounds\n",
                megaBytes * (double) CLOCKS_PER_SEC * rounds / duration / 2,
                duration / (double) CLOCKS_PER_SEC , megaBytes, rounds);
}

int main(int argc, char** argv){
        clock_t start = clock();
        int millions = 100;
        int megaBytes = 50;
        int rounds = 1000  * millions / 400 / megaBytes;
        if (rounds < 1)
                rounds = 1;
        seed_t value;
        clock_t duration;
        if (argc > 1 && atol(argv[1]) != 0)
                millions = atol(argv[1]);
        if (argc > 2 && atol(argv[2]) != 0)
                megaBytes = atol(argv[2]);
        value = calcRandom(millions);
        duration = clock() - start;
        printf ("%.3f HamaMips %.3f sec value: %04x-%04x\n",
                millions * (double) CLOCKS_PER_SEC / duration,
                duration / (double) CLOCKS_PER_SEC,
                (value >> 16) & 0xffff, value & 0xffff);
        memSpeed(megaBytes, rounds);
}