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); }