int32 fib(int32 n)
{
if (n > 1) return n + fib(n-1); else return 1;
}
static jlong fibN(JNIEnv *env, jclass clazz, jlong n){
return fib(n);
}
static jlong fib(jlong n) {
if(n==0) return 0;
if(n==1) return 1;
return fib(n-1)+fib(n-2);
}
int main() {
if( fib( 1,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 ) != 6766 ) fail(__LINE__);
_PASS;
}
int fib(int i) {
return (i>1) ? fib(i-1) + fib(i-2) : i;
}
int main()
{
printf("%u\n", fib(33));
return 0;
}
void print_fib(int n) {
printf("%d\n", fib(n));
}
void main(void)
{
long long n = 100000000;
printf("the %lldth fib number is %lld\n", n, fib(n));
}
//Fib function only - recursive
int fib(int n)
{
if ( n <= 1 )
return n;
return fib(n-1) + fib(n-2);
}
int main(){
std::cout<<fib(3)<<endl;
}
static int _cffi_d_fib(int * x0)
{
return fib(x0);
}
int fib ( int n ){
if ( n > 1 )
return fib( n-1 ) + fib ( n-2 );
return n; // defaults case to handle n = 0 and 1
}
int fib(int n) {
if (n < 2) { return n; }
return fib(n-1) + fib(n-2);
}
int main(int argc, char **argv)
{
std::cout<<fib(atoi(argv[1]))<<std::endl;
return 0;
}
int
main(int argc, char **argv)
{
char *s_arch;
char *executable;
cpu_arch_t arch;
cpu_t *cpu;
uint8_t *RAM;
FILE *f;
int ramsize;
int r1, r2;
uint64_t t1, t2, t3, t4;
unsigned start_no = START_NO;
int singlestep = SINGLESTEP_NONE;
int log = 1;
int print_ir = 1;
/* parameter parsing */
if (argc < 3) {
printf("Usage: %s executable [arch] [itercount] [entries]\n", argv[0]);
return 0;
}
s_arch = argv[1];
executable = argv[2];
if (argc >= 4)
start_no = atoi(argv[3]);
if (!strcmp("mips", s_arch))
arch = CPU_ARCH_MIPS;
else if (!strcmp("m88k", s_arch))
arch = CPU_ARCH_M88K;
else if (!strcmp("arm", s_arch))
arch = CPU_ARCH_ARM;
else if (!strcmp("fapra", s_arch))
arch = CPU_ARCH_FAPRA;
else {
printf("unknown architecture '%s'!\n", s_arch);
return 0;
}
ramsize = 5*1024*1024;
RAM = (uint8_t*)malloc(ramsize);
cpu = cpu_new(arch, 0, 0);
cpu_set_flags_codegen(cpu, CPU_CODEGEN_OPTIMIZE);
cpu_set_flags_debug(cpu, 0
| (print_ir? CPU_DEBUG_PRINT_IR : 0)
| (print_ir? CPU_DEBUG_PRINT_IR_OPTIMIZED : 0)
| (log? CPU_DEBUG_LOG :0)
| (singlestep == SINGLESTEP_STEP? CPU_DEBUG_SINGLESTEP : 0)
| (singlestep == SINGLESTEP_BB? CPU_DEBUG_SINGLESTEP_BB : 0)
);
cpu_set_ram(cpu, RAM);
/* load code */
if (!(f = fopen(executable, "rb"))) {
printf("Could not open %s!\n", executable);
return 2;
}
cpu->code_start = START;
cpu->code_end = cpu->code_start + fread(&RAM[cpu->code_start], 1, ramsize-cpu->code_start, f);
fclose(f);
cpu->code_entry = cpu->code_start + ENTRY;
cpu_tag(cpu, cpu->code_entry);
cpu_translate(cpu); /* force translation now */
printf("\n*** Executing...\n");
printf("number of iterations: %u\n", start_no);
uint32_t *reg_pc, *reg_lr, *reg_param, *reg_result;
switch (arch) {
case CPU_ARCH_M88K:
reg_pc = &((m88k_grf_t*)cpu->rf.grf)->sxip;
reg_lr = &((m88k_grf_t*)cpu->rf.grf)->r[1];
reg_param = &((m88k_grf_t*)cpu->rf.grf)->r[2];
reg_result = &((m88k_grf_t*)cpu->rf.grf)->r[2];
break;
case CPU_ARCH_MIPS:
reg_pc = &((reg_mips32_t*)cpu->rf.grf)->pc;
reg_lr = &((reg_mips32_t*)cpu->rf.grf)->r[31];
reg_param = &((reg_mips32_t*)cpu->rf.grf)->r[4];
reg_result = &((reg_mips32_t*)cpu->rf.grf)->r[4];
break;
case CPU_ARCH_ARM:
reg_pc = &((reg_arm_t*)cpu->rf.grf)->pc;
reg_lr = &((reg_arm_t*)cpu->rf.grf)->r[14];
reg_param = &((reg_arm_t*)cpu->rf.grf)->r[0];
reg_result = &((reg_arm_t*)cpu->rf.grf)->r[0];
break;
case CPU_ARCH_FAPRA:
reg_pc = &((reg_fapra32_t*)cpu->rf.grf)->pc;
reg_lr = &((reg_fapra32_t*)cpu->rf.grf)->r[0];
reg_param = &((reg_fapra32_t*)cpu->rf.grf)->r[3];
reg_result = &((reg_fapra32_t*)cpu->rf.grf)->r[3];
break;
default:
fprintf(stderr, "architecture %u not handled.\n", arch);
exit(EXIT_FAILURE);
}
*reg_pc = cpu->code_entry;
*reg_lr = RET_MAGIC;
*reg_param = start_no;
printf("GUEST run..."); fflush(stdout);
t1 = abs_time();
cpu_run(cpu, debug_function);
t2 = abs_time();
r1 = *reg_result;
printf("done!\n");
printf("HOST run..."); fflush(stdout);
t3 = abs_time();
r2 = fib(start_no);
t4 = abs_time();
printf("done!\n");
cpu_free(cpu);
printf("Time GUEST: %lld\n", t2-t1);
printf("Time HOST: %lld\n", t4-t3);
printf("Result HOST: %d\n", r2);
printf("Result GUEST: %d\n", r1);
printf("GUEST required \033[1m%.2f%%\033[22m of HOST time.\n", (float)(t2-t1)/(float)(t4-t3)*100);
if (r1 == r2)
printf("\033[1mSUCCESS!\033[22m\n\n");
else
printf("\033[1mFAILED!\033[22m\n\n");
return 0;
}
int main(int argc, char** argv)
{
pid_t child1, child2;
int do_vfork = 1; //argc == 1;
int n, sum = 0;
int result;
char *arg[5];
char **env = NULL;
char carg[10], csum[10];
if (find_dynamo_library())
printf("rio\n");
else
printf("native\n");
//printf("%d %s %s %s\n", argc, argv[0], argv[1], argv[2]);
if (argc < 3) { // start calculation
if (2 == argc) // vfork-fib 10
n = atoi(argv[1]);
else
n = N;
printf("parent fib(%d)=%d\n", n, fib(n));
sum = 0;
} else {
assert(argc == 3); // vfork-fib fib 10
n = atoi(argv[2]);
sum = 0;
}
pf("\tfib %d\n", n);
if (n <= 1) { // base case
pf("base case\n");
_exit(1);
}
// now spawn two children
arg[0] = argv[0];
arg[1] = "fib";
arg[3] = NULL;
if (do_vfork) { /* default */
pf("using vfork()\n");
child1 = vfork();
} else {
pf("using fork()\n");
child1 = fork();
}
if (child1 < 0) {
perror("ERROR on fork");
} else if (child1 == 0) {
snprintf(carg, 10, "%d", n-2);
arg[2] = carg;
#if 0
pf("execing %d %s %s=%s %s\n",
3, arg[0], carg, arg[1], arg[2]);
#endif
result = execve(arg[0], arg, env);
if (result < 0)
perror("ERROR in execve");
} else {
pid_t result;
int status;
int children = 2;
if (do_vfork) { /* default */
pf("second child using vfork()\n");
child2 = vfork();
} else {
pf("second child using fork()\n");
child2 = fork();
}
if (child2 < 0) {
perror("ERROR on fork");
} else if (child2 == 0) {
snprintf(carg, 10, "%d", n-1);
arg[2] = carg;
result = execve(arg[0], arg, env);
if (result < 0) perror("ERROR in execve");
}
while(children > 0) {
pf("parent waiting for %d children\n", children);
result = wait(&status);
assert(result == child2 || result == child1);
assert(WIFEXITED(status));
//printf("child %d has exited with status=%d %d\n", result, status, WEXITSTATUS(status));
sum+=WEXITSTATUS(status);
if (children == 2 && result == child1)
pf("first child before second\n");
else
pf("second child before first\n");
children--;
}
#if 0
result = waitpid(child2, &status, 0);
assert(result == child2);
assert(WIFEXITED(status));
pf("child2 has exited with status=%d %d\n", status, WEXITSTATUS(status));
sum+=WEXITSTATUS(status);
pf("parent waiting for child1 %d\n", child1);
result = waitpid(child1, &status, 0);
assert(result == child1);
assert(WIFEXITED(status));
pf("child1 has exited with status=%d %d\n", status, WEXITSTATUS(status));
sum+=WEXITSTATUS(status);
#endif
}
#ifdef DEBUG
printf("\tfib(%d)=%d [%d] %s\n", n, sum, fib(n), sum == fib(n) ? "OK" : "BAD");
#else
if (argc == 1)
printf("\tfib(%d)=%d [%d] %s\n", n, sum, fib(n), sum == fib(n) ? "OK" : "BAD");
#endif
_exit(sum);
}
int fib(int n) {
if(n<2) return 1;
return fib(n-1) + fib(n-2);
}
int fib(int n)
{
return n<=2?1:fib(n-1)+fib(n-2);
}
int fib(int num) {
if (num <= 2)
return 1;
else
return fib(num - 1) + fib(num - 2);
}
int main() {
// Initialize RNG
dsfmt_gv_init_gen_rand(0);
double t, tmin;
// fib(20)
assert(fib(20) == 6765);
int f = 0;
tmin = INFINITY;
volatile int fibarg = 20; // prevent constant propagation
for (int i=0; i<NITER; ++i) {
t = clock_now();
for (int j = 0; j < 1000; j++)
f += fib(fibarg);
t = clock_now()-t;
if (t < tmin) tmin = t;
}
print_perf("recursion_fibonacci", tmin / 1000);
// parse_bin
tmin = INFINITY;
for (int i=0; i<NITER; ++i) {
t = clock_now();
char s[11];
for (int k=0; k<1000 * 100; ++k) {
uint32_t n = dsfmt_gv_genrand_uint32();
sprintf(s, "%x", n);
uint32_t m = (uint32_t)parse_int(s, 16);
assert(m == n);
}
t = clock_now()-t;
if (t < tmin) tmin = t;
}
print_perf("parse_integers", tmin / 100);
// // array constructor
// tmin = INFINITY;
// for (int i=0; i<NITER; ++i) {
// t = clock_now();
// double *a = ones(200,200);
// free(a);
// t = clock_now()-t;
// if (t < tmin) tmin = t;
// }
// print_perf("ones", tmin);
//
// // A*A'
// //SUBROUTINE DGEMM(TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC)
// double *b = ones(200, 200);
// tmin = INFINITY;
// for (int i=0; i<NITER; ++i) {
// t = clock_now();
// double *c = matmul_aat(200, b);
// free(c);
// t = clock_now()-t;
// if (t < tmin) tmin = t;
// }
// free(b);
// print_perf("AtA", tmin);
// mandel
/* The initialization on the next line is deliberately volatile to
* prevent gcc from optimizing away the entire loop.
* (First observed in gcc 4.9.2)
*/
static volatile int mandel_sum_init = 0;
int mandel_sum2 = mandel_sum_init;
tmin = INFINITY;
for (int i=0; i<NITER; ++i) {
int *M;
t = clock_now();
for (int j = 0; j < 100; j++) {
M = mandelperf();
if (j == 0) {
int mandel_sum = 0;
// for (int ii = 0; ii < 21; ii++) {
// for (int jj = 0; jj < 26; jj++) {
// printf("%4d", M[26*ii + jj]);
// }
// printf("\n");
// }
for (int k = 0; k < 21*26; k++) {
mandel_sum += M[k];
}
assert(mandel_sum == 14791);
mandel_sum2 += mandel_sum;
}
free(M);
}
t = clock_now()-t;
if (t < tmin) tmin = t;
}
assert(mandel_sum2 == 14791 * NITER);
print_perf("userfunc_mandelbrot", tmin / 100);
// sort
tmin = INFINITY;
for (int i=0; i<NITER; ++i) {
t = clock_now();
double *d = myrand(5000);
quicksort(d, 0, 5000-1);
free(d);
t = clock_now()-t;
if (t < tmin) tmin = t;
}
print_perf("recursion_quicksort", tmin);
// pi sum
double pi;
tmin = INFINITY;
for (int i=0; i<NITER; ++i) {
t = clock_now();
pi = pisum();
t = clock_now()-t;
if (t < tmin) tmin = t;
}
assert(fabs(pi-1.644834071848065) < 1e-12);
print_perf("iteration_pi_sum", tmin);
// rand mat stat
struct double_pair r;
tmin = INFINITY;
for (int i=0; i<NITER; ++i) {
t = clock_now();
r = randmatstat(1000);
t = clock_now()-t;
if (t < tmin) tmin = t;
}
// assert(0.5 < r.s1 && r.s1 < 1.0 && 0.5 < r.s2 && r.s2 < 1.0);
print_perf("matrix_statistics", tmin);
// rand mat mul
tmin = INFINITY;
for (int i=0; i<NITER; ++i) {
t = clock_now();
double *C = randmatmul(1000);
assert(0 <= C[0]);
free(C);
t = clock_now()-t;
if (t < tmin) tmin = t;
}
print_perf("matrix_multiply", tmin);
// printfd
tmin = INFINITY;
for (int i=0; i<NITER; ++i) {
t = clock_now();
printfd(100000);
t = clock_now()-t;
if (t < tmin) tmin = t;
}
print_perf("print_to_file", tmin);
return 0;
}
int main(int argc, char *argv[]){
printf("%d\n", fib(atoi(argv[1]) - 1));
return 0;
}
int fib(int n) {
return n < 2 ? n : fib(n-1) + fib(n-2);
}
int
fib(int n) {
if (n == 0 || n == 1) return 1;
return fib(n - 2) + fib(n - 1);
}
int fib(int n) {
if (n == 0) return 0;
if (n == 1) return 1;
return fib(n-1) + fib(n-2);
}
