Script Programming(스크립트 프로그래밍)

/*
 * Filename: ezmult_003.c
 *
 * Compile: gcc -o ezmult_003 ezmult_003.c -lform -lncurses
 *
 * Execute: ./ezmult_003
 *
 *    Date: 2014. 1. 6. (Mon)  v0.002
 *    Date: 2014. 1. 8. (Wed)  v0.003
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <form.h>
#include <ncurses.h>

int main()
{
    int x0, y0, z0;
    int s01, s02, t0;
    int x, y, z;
    int s1, s2, t;
    int i, j;
    int flag_insert_mode = 1;
    int o1 = 0;
    int o2 = 0;
    int o3 = 0;

    FIELD *field[4];
    FORM  *my_form;
    int ch;
 
    /* curses 초기화하기 */
    initscr();
    start_color();    // 색상을 사용하려면 initscr() 호출 후 즉시 이를 호출해야 함
    nonl();            // 필드에서 엔터 키가 작용되게 하기 위함
    cbreak();
    noecho();
    keypad(stdscr, TRUE);

    srand(time(NULL));
    x = rand()/(RAND_MAX + 1.0)*90 + 10;
    y = rand()/(RAND_MAX + 1.0)*90 + 10;
    z = x*y;
    s1 = (x/10)*(y/10);
    s2 = (x%10)*(y%10);
    t = (x/10)*(y%10) + (x%10)*(y/10);
   
    if (s1 < 10)
    {
         o1 = 1;
    }
    if (t < 100)
    {
         o2 = 1;
    }
    if (z < 1000)
    {
         o3 = 1;
    }
    refresh();
    

    /* 필드 초기화 */
    field[0] = new_field(1, 4-o1,  6, 14+o1, 0, 0);
    field[1] = new_field(1, 3-o2,  7, 14+o2, 0, 0);
    field[2] = new_field(1, 4-o3,  9, 14+o3, 0, 0);
    field[3] = NULL;

    /* 폼 생성하여 붙여 넣기 */
    my_form = new_form(field);
    post_form(my_form);
    refresh();

     /* 색상 초기화 */
    init_pair(1, COLOR_WHITE, COLOR_GREEN);
    init_pair(2, COLOR_WHITE, COLOR_GREEN);
    init_pair(3, COLOR_WHITE, COLOR_GREEN);
    init_pair(4, COLOR_MAGENTA, COLOR_BLACK);
    init_pair(5, COLOR_CYAN, COLOR_BLACK); 
    init_pair(6, COLOR_WHITE, COLOR_BLACK);
    init_pair(7, COLOR_BLACK, COLOR_WHITE);

    x0 = rand()/(RAND_MAX + 1.0)*90 + 10;
    y0 = rand()/(RAND_MAX + 1.0)*90 + 10;
    z0 = x0*y0;
    s01 = (x0/10)*(y0/10);
    s02 = (x0%10)*(y0%10);
    t0 = (x0/10)*(y0%10) + (x0%10)*(y0/10);

    mvprintw(3, 4, "%4d", x0);
    mvprintw(4, 3, "x%4d", y0);
    mvprintw(5, 3, "-----");
    mvprintw(6, 4, "%2d%02d", s01, s02);
    mvprintw(7, 4, "%3d", t0);
    mvprintw(8, 3, "-----");
    mvprintw(9, 4, "%4d", z0);
    refresh();

    mvprintw(3, 14, "%4d", x);
    mvprintw(4, 13, "x%4d", y);
    mvprintw(5, 13, "-----");
    mvprintw(8, 13, "-----");
    attron(COLOR_PAIR(7));
    mvprintw(0, 0, "Ins");
    attron(COLOR_PAIR(6));
    move(6, 14);
    refresh();

    set_field_type(field[0], TYPE_INTEGER, 0, 0, 9999);
    set_field_type(field[1], TYPE_INTEGER, 0, 0, 999);
    set_field_type(field[2], TYPE_INTEGER, 0, 0, 9999);
    field_opts_on(field[0], O_EDIT);
    field_opts_on(field[1], O_EDIT);
    field_opts_on(field[2], O_EDIT);
    field_opts_on(field[0], O_ACTIVE);
    field_opts_on(field[1], O_ACTIVE);
    field_opts_on(field[2], O_ACTIVE);

 
    /* 필드 옵션 설정 */
    set_field_back(field[0], A_UNDERLINE); 
    set_field_back(field[1], A_UNDERLINE); 

    set_field_back(field[2], A_UNDERLINE); 

    /* 필드 옵션 설정 */
    set_field_fore(field[0], COLOR_PAIR(1));
    set_field_back(field[0], COLOR_PAIR(2));
    set_field_fore(field[1], COLOR_PAIR(1));

    set_field_back(field[1], COLOR_PAIR(2));
    set_field_fore(field[2], COLOR_PAIR(1));
    set_field_back(field[2], COLOR_PAIR(2));

    if (s1 >= 10)
        move(6, 14);
    else
        move(6, 15);
    refresh();

    /* 사용자 요구에 따라 번복 여부 결정 */
    while((ch = getch()) != KEY_F(1) && ch != 0x1B && ch != 0x0D)   
        switch(ch)
      {

           case KEY_DOWN:
           case KEY_ENTER:
               /* 다음 필드로 가기 */
               form_driver(my_form, REQ_NEXT_FIELD);
               break;
          case KEY_UP:
              /* 이전 필드로 가기 */
              form_driver(my_form, REQ_PREV_FIELD);
              break;
         case KEY_BACKSPACE:
         case 0x7F:
              form_driver(my_form, REQ_DEL_PREV);
              break;
         case KEY_IC:
              if (flag_insert_mode != 0)
             {
                 form_driver(my_form, REQ_OVL_MODE);
                 getyx(stdscr, j, i);
                 mvprintw(0, 0, "   ");
                 move(j, i);
                 flag_insert_mode = 0;
             }
             else
            {
                 form_driver(my_form, REQ_INS_MODE);
                 getyx(stdscr, j, i);
                attron(COLOR_PAIR(7));
                mvprintw(0, 0, "Ins");
                attron(COLOR_PAIR(6));
                move(j, i);
                flag_insert_mode = 1;
            }
            break;
        case KEY_DC:
            form_driver(my_form, REQ_DEL_CHAR);
            break;
        case KEY_LEFT:
            form_driver(my_form, REQ_LEFT_CHAR);
            break;
        case KEY_RIGHT:
            form_driver(my_form, REQ_RIGHT_CHAR);
            break;
        default:
            form_driver(my_form, ch);
            break;
       }
    }
 
    form_driver(my_form, REQ_NEXT_FIELD);
 
    attron(COLOR_PAIR(6));
    mvprintw(13, 0, "You have answered");
    if (atoi(field_buffer(field[0], 0)) == s1*100 + s2)
         attron(COLOR_PAIR(5));
    else
         attron(COLOR_PAIR(4));
    mvprintw(14, 8, "%4d", atoi(field_buffer(field[0], 0)));
    if (atoi(field_buffer(field[1], 0)) == t)
         attron(COLOR_PAIR(5));
    else
         attron(COLOR_PAIR(4));
    mvprintw(15, 8, "%3d", atoi(field_buffer(field[1], 0)));
    if (atoi(field_buffer(field[2], 0)) == z)
         attron(COLOR_PAIR(5));
    else
         attron(COLOR_PAIR(4));
    mvprintw(16, 8, "%4d", atoi(field_buffer(field[2], 0)));

    attron(COLOR_PAIR(6));
    mvprintw(13, 20, "Right answer is");
    mvprintw(14, 28, "%2d%02d", s1, s2);
    mvprintw(15, 28, "%3d", t);
    mvprintw(16, 28, "%4d", z);
    if (atoi(field_buffer(field[0], 0)) == s1*100 + s2
         && atoi(field_buffer(field[1], 0)) == t
         && atoi(field_buffer(field[2], 0)) == z)
        mvprintw(18, 0, "    Your answer is right.");
    else
        mvprintw(18, 0, "    Your answer is wrong.");
    mvprintw(21, 0, "Press any key to quit...");
    getch();
   
    /* 폼을 떼어내고 메모리를 해제한다. */
    unpost_form(my_form);
    free_form(my_form);
    free_field(field[0]);
    free_field(field[1]);
    free_field(field[2]);

    endwin();

    return 0;
}
 

// Filename: testIntSize.c

int main()
{
#include <stdio.h>

int main()
{
    printf("sizeof(int) = %d\n", sizeof(int));
    printf("sizeof(long) = %d\n", sizeof(long));

    return 0;
}

/*
 * Filename: eulerPhiGoodC_01.c
 *
 *  Purpose:
 *          Calculate the Euler phi function of a given nonzero integer
 *          with using its muliplicative property.
 *
 *          The Euler phi function of a given positive integer n is defined as.
 *          the number of positive integers which are relative prime to n
 *          from 1 to n.
 *
 * Compile: gcc -o eulerPhiGoodC_01 eulerPhiGoodC_01.c
 *    Or
 * Compile: cl /DVC2010 eulerPhiGoodC_01.c
 *
 * Execute: ./eulerPhiGoodC_01 [nnn]
 *    Or
 * Execute: eulerPhiGoodC_01 [nnn]
 *
 *  Date: 2011. 11.  7 (Mon)    eulerPhiGoodPython_01.py
 *  Date: 2013. 12. 13 (Fri)    eulerPhiGoodC_01.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#ifdef VC2010
  #include "inttypes.h"
  #define strtoll _strtoi64
#else
  #include <inttypes.h>
#endif
 
void printUsage()
{
    printf("Usage: eulerPhiGoodC_01 [nnnnnn]\n");
    printf("nnnnnn should be an integer.\n");
}

long long gcd(long long a, long long b)
{
    long long a1 = abs(a);
    long long b1 = abs(b);
    long long q = a1;
    long long r = b1;
    long long t;
    while (r != 0)
    {
        t = r;
        r = q % r;
        q = t;
    }
    return q;
}

int divide_each(long long n)
{
    long long a = 3;

    if ((n & 0x1) == 0 || n <= 1)
        return 0;
    else if (n == 2)
        return 1;

    while (a*a <= n)
    {
        if ((n % a) == 0)
            return 0;
        a += 2;
    }
    
    return 1;
}

int is_prime(long long n)
{
    return divide_each(n);
}

long long next_prime(long long n)
{
    long long k = llabs(n);
   
    k = k + 1;
    if (k <= 2)
    {
        return 2LL;
    }

    if ((k % 2) == 0 && k > 2)
        k += 1;
    while (!is_prime(k))
        k += 2;

    return k;
}

int main(int argc, const char *argv[])
{
    long long n = 0;
    long long cnt = 0;
    long long nphi = 0;
    long long sum = 0;
    long long t = 0;
    long long g = 1;
    long long m = 0;
    long long p = 1;
    long long *factors = (long long *)malloc(sizeof(long long)*200);
    long long nfactor = 0;
    long long ndivisor = 1;   // the number of positive divisors of the input integer
    long long nsum = 1;       // the sum of all positive divisors of the input integer
    int ndx = 0;        // index of storing position factor in factors
    long long *divisors = NULL;
    long long last_prime;
    int i, j, k;

    if (argc != 2)
    {
        printUsage();
        exit(1);
    }
    else
    {
        n = strtoll(argv[1], NULL, 10);
        n = llabs(n);
        if (n != 0)
        {
            t = n;
            k = 0;
            m = 0;  // multiplicity of prime factor
            ndivisor = 1;   // the number of positive divisors of the input integer
            nsum = 1;       // the sum of all positive divisors of the input integer
            nphi = 1;       // the numner of positive integers relative prime to the input integer
    
            p = 1;
            while (t > 1 && p*p <= n)
            {
                p = next_prime(p);
                m = 0;
                while (t % p == 0)
                {
                    t = (long long)(t / p);
                    m = m + 1;
                }

                if (m > 0)
                {
                    factors[ndx] = p;
                    ndx += 1;
                    factors[ndx] = m;
                    ndx += 1;
                    nfactor += 1;
                    ndivisor *= (m + 1);
                    nsum *= (long long)((pow(p, m+1) - 1)/(p - 1));
                    nphi *= (long long)(pow(p, m - 1)*(p - 1));
                }
            }
    

            if (is_prime(t))
            {
                m = 1;
                factors[ndx] = t;
                ndx += 1;
                factors[ndx] = m;
                ndx += 1;
                nfactor += 1;
                ndivisor *= (m + 1);
                nsum *= (long long)((pow(t, m+1) - 1)/(t - 1));
                nphi *= (long long)pow(t, m - 1)*(t - 1);
                m = 0;
            }
                
            printf("Prime factorization: %"PRId64" = ", n);
            for (i = 0 ; i < 2*nfactor; i += 2)
            {
                printf("%"PRId64"^{%"PRId64"} ", factors[i], factors[i + 1]);
            }
            printf("\n");
            printf("The number of positive divisors:  tau(%"PRId64") =  %"PRId64".\n", n, ndivisor);
            printf("The sum of all positive divisors:  sigma(%"PRId64") = %"PRId64".\n", n, nsum);
            printf("The number of positive integers relatively prime:  phi(%"PRId64") = %"PRId64"\n", n, nphi);
            if (nsum == n + 1)
                printf("The integer %"PRId64" is a prime number.\n", n);
            else
                printf("The integer %"PRId64" is not a prime number.\n", n);

            divisors = (long long *)malloc(sizeof(long long)*ndivisor);

            cnt = 0;
            ndx = 0;
            divisors[ndx] = 1;
            ndx += 1;
            cnt = 1;
            for (i = 0; i < 2*nfactor; i += 2)
            {
                p = factors[i];
                m = factors[i + 1];
                for (k = 1; k <= m; k++)
                {
                    for (j = 0; j < cnt; j++)
                    {
                        divisors[ndx] = divisors[j]*pow(p, k);
                        ndx += 1;
                    }
                }
                cnt = ndx;
            }
            printf("The positive divisors of %"PRId64" are\n", n);
            for (i = 0; i < ndivisor - 1; i++)
            {
                printf("%"PRId64", ", divisors[i]);
            }
            printf("%"PRId64".\n", divisors[ndivisor - 1]);
        }
    }
 
    free(factors);
    free(divisors);
 
    return 0;
}

/*
 * Filename: testLongLong0.c
 *
 * Compile: gcc -o testLongLong0 testLongLong0.c
 *   or
 * Compile: cl testLongLong0.c
 */

#include <stdio.h>

int main()
{
    printf("Maximum long long value is %40lld\n", 9223372036854775807LL);
    printf("Maximum long long value is %40llu\n", 9223372036854775807ULL);
    printf("Maximum long long value is %40lld\n", 9223372036854775808LL);
    printf("Maximum long long value is %40llu\n", 9223372036854775808ULL);

    return 0;
}

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main()
{
    printf("Maximum int64 value is %40" PRId64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRIx64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRIX64 "\n", 9223372036854775807L);
    printf("       uint64 value is %40" PRIu64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRId64 "\n", 9223372036854775808L);
    printf("Maximum int64 value is %40" PRIx64 "\n", 9223372036854775808L);
    printf("Maximum int64 value is %40" PRIX64 "\n", 9223372036854775808L);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 9223372036854775808L);
    printf("Maximum uint64 value is %40" PRIx64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIX64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 18446744073709551615ULL);

    printf("Maximum int64 value is |%-40" PRId64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIu64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIx64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIX64 "|\n", INT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIx64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIX64 "|\n", UINT64_MAX);

    return 0;
}

/*
-----------------
  Execute Result:
-----------------
Maximum int64 value is                      9223372036854775807
Maximum int64 value is                         7fffffffffffffff
Maximum int64 value is                         7FFFFFFFFFFFFFFF
       uint64 value is                      9223372036854775807
Maximum int64 value is                     -9223372036854775808
Maximum int64 value is                         8000000000000000
Maximum int64 value is                         8000000000000000
Maximum uint64 value is                      9223372036854775808
Maximum uint64 value is                         ffffffffffffffff
Maximum uint64 value is                         FFFFFFFFFFFFFFFF
Maximum uint64 value is                     18446744073709551615
Maximum int64 value is |9223372036854775807                     |
Maximum int64 value is |9223372036854775807                     |
Maximum int64 value is |7fffffffffffffff                        |
Maximum int64 value is |7FFFFFFFFFFFFFFF                        |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |ffffffffffffffff                        |
Maximum uint64 value is |FFFFFFFFFFFFFFFF                        |
*/

#include <stdio.h>
#include <stdio.h>
#include "inttypes.h"

int main()
{
    printf("Maximum int64 value is %40" PRId64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRIx64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRIX64 "\n", 9223372036854775807L);
    printf("       uint64 value is %40" PRIu64 "\n", 9223372036854775807L);
    printf("Maximum int64 value is %40" PRId64 "\n", 9223372036854775808L);
    printf("Maximum int64 value is %40" PRIx64 "\n", 9223372036854775808L);
    printf("Maximum int64 value is %40" PRIX64 "\n", 9223372036854775808L);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 9223372036854775808L);
    printf("Maximum uint64 value is %40" PRIx64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIX64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 18446744073709551615ULL);

    printf("Maximum int64 value is |%-40" PRId64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIu64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIx64 "|\n", INT64_MAX);
    printf("Maximum int64 value is |%-40" PRIX64 "|\n", INT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIx64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIX64 "|\n", UINT64_MAX);

    return 0;
}

/*
-----------------
  Execute Result:
-----------------
Maximum int64 value is                      9223372036854775807
Maximum int64 value is                         7fffffffffffffff
Maximum int64 value is                         7FFFFFFFFFFFFFFF
       uint64 value is                      9223372036854775807
Maximum int64 value is                     -9223372036854775808
Maximum int64 value is                         8000000000000000
Maximum int64 value is                         8000000000000000
Maximum uint64 value is                      9223372036854775808
Maximum uint64 value is                         ffffffffffffffff
Maximum uint64 value is                         FFFFFFFFFFFFFFFF
Maximum uint64 value is                     18446744073709551615
Maximum int64 value is |9223372036854775807                     |
Maximum int64 value is |9223372036854775807                     |
Maximum int64 value is |7fffffffffffffff                        |
Maximum int64 value is |7FFFFFFFFFFFFFFF                        |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |ffffffffffffffff                        |
Maximum uint64 value is |FFFFFFFFFFFFFFFF                        |
*/

/*
 * Filename: testLongLong2.c
 *
 * Compile: gcc -o testLongLong2 testLongLong2.c
 *     or
 * Compile:cl testLongLong2.c
 *
 * See: http://en.wikipedia.org/wiki/Printf_format_string
 * See: http://msinttypes.googlecode.com/svn/trunk/inttypes.h
 * See: http://msinttypes.googlecode.com/svn/trunk/stdint.h
 * See: http://en.wikibooks.org/wiki/C_Programming/C_Reference/inttypes.h
 */

#include <stdio.h>
#include "stdint.h"      //  #include <inttypes.h>  for gcc or Visual C++ 2010
#include "inttypes.h"    //  #include <inttypes.h>  for gcc

int main()
{
    printf(" INT64_MAX = %30" PRId64 "\n", INT64_MAX);
    printf(" INT64_MAX = %30" PRIx64 "\n", INT64_MAX);
    printf("UINT64_MAX = %30" PRIu64 "\n", UINT64_MAX);
    printf("UINT64_MAX = %30" PRIx64 "\n", UINT64_MAX);
    printf("\n");

    printf("Maximum  int64 value is %40" PRId64 "\n", 9223372036854775807LL);
    printf("Maximum  int64 value is %40" PRIx64 "\n", 9223372036854775807LL);
    printf("Maximum  int64 value is %40" PRIX64 "\n", 9223372036854775807LL);
    printf("        uint64 value is %40" PRIu64 "\n", 9223372036854775807LL);
    printf("Maximum  int64 value is %40" PRId64 "\n", 9223372036854775808ULL);
    printf("Maximum  int64 value is %40" PRIx64 "\n", 9223372036854775808ULL);
    printf("Maximum  int64 value is %40" PRIX64 "\n", 9223372036854775808ULL);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 9223372036854775808ULL);
    printf("Maximum uint64 value is %40" PRIx64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIX64 "\n", 18446744073709551615ULL);
    printf("Maximum uint64 value is %40" PRIu64 "\n", 18446744073709551615ULL);

    printf("Maximum  int64 value is |%-40" PRId64 "|\n", INT64_MAX);
    printf("Maximum  int64 value is |%-40" PRIu64 "|\n", INT64_MAX);
    printf("Maximum  int64 value is |%-40" PRIx64 "|\n", INT64_MAX);
    printf("Maximum  int64 value is |%-40" PRIX64 "|\n", INT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIu64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIx64 "|\n", UINT64_MAX);
    printf("Maximum uint64 value is |%-40" PRIX64 "|\n", UINT64_MAX);

    return 0;
}

/*
-----------------
  Execute Result:
-----------------
 INT64_MAX =            9223372036854775807
 INT64_MAX =               7fffffffffffffff
UINT64_MAX =           18446744073709551615
UINT64_MAX =               ffffffffffffffff

Maximum  int64 value is                      9223372036854775807
Maximum  int64 value is                         7fffffffffffffff
Maximum  int64 value is                         7FFFFFFFFFFFFFFF
        uint64 value is                      9223372036854775807
Maximum  int64 value is                     -9223372036854775808
Maximum  int64 value is                         8000000000000000
Maximum  int64 value is                         8000000000000000
Maximum uint64 value is                      9223372036854775808
Maximum uint64 value is                         ffffffffffffffff
Maximum uint64 value is                         FFFFFFFFFFFFFFFF
Maximum uint64 value is                     18446744073709551615
Maximum  int64 value is |9223372036854775807                     |
Maximum  int64 value is |9223372036854775807                     |
Maximum  int64 value is |7fffffffffffffff                        |
Maximum  int64 value is |7FFFFFFFFFFFFFFF                        |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |18446744073709551615                    |
Maximum uint64 value is |ffffffffffffffff                        |
Maximum uint64 value is |FFFFFFFFFFFFFFFF                        |
*/

// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
// Translated to C++ 30 May 1997 by William D Clinger of Northeastern Univ.
//
//      This is no substitute for real applications.  No actual application
//      is likely to behave in exactly this way.  However, this benchmark was
//      designed to be more representative of real applications than other
//      Java GC benchmarks of which we are aware.
//      It attempts to model those properties of allocation requests that
//      are important to current GC techniques.
//      It is designed to be used either to obtain a single overall performance
//      number, or to give a more detailed estimate of how collector
//      performance varies with object lifetimes.  It prints the time
//      required to allocate and collect balanced binary trees of various
//      sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//      allocates roughly the same amount of memory.
//      Two data structures are kept around during the entire process, so
//      that the measured performance is representative of applications
//      that maintain some live in-memory data.  One of these is a tree
//      containing many pointers.  The other is a large array containing
//      double precision floating point numbers.  Both should be of comparable
//      size.
//
//      The results are only really meaningful together with a specification
//      of how much memory was used.  It is possible to trade memory for
//      better time performance.  This benchmark should be run in a 32 MB
//      heap, though we don't currently know how to enforce that uniformly.
//
//      Unlike the original Ellis and Kovac benchmark, we do not attempt
//      measure pause times.  This facility should eventually be added back
//      in.  There are several reasons for omitting it for now.  The original
//      implementation depended on assumptions about the thread scheduler
//      that don't hold uniformly.  The results really measure both the
//      scheduler and GC.  Pause time measurements tend to not fit well with
//      current benchmark suites.  As far as we know, none of the current
//      commercial Java implementations seriously attempt to minimize GC pause
//      times.

#include <new>          // #include <new.h>
#include <iostream>     // #include <iostream.h>
#include <sys/time.h>

#ifdef GC
#  include "gc.h"
#endif

using namespace std;

//  These macros were a quick hack for the Macintosh.
//
//  #define currentTime() clock()
//  #define elapsedTime(x) ((1000*(x))/CLOCKS_PER_SEC)

#define currentTime() stats_rtclock()
#define elapsedTime(x) (x)

/* Get the current time in milliseconds */

unsigned
stats_rtclock( void )
{
  struct timeval t;
  struct timezone tz;

  if (gettimeofday( &t, &tz ) == -1)
    return 0;
  return (t.tv_sec * 1000 + t.tv_usec / 1000);
}

static const int kStretchTreeDepth    = 18;      // about 16Mb
static const int kLongLivedTreeDepth  = 16;  // about 4Mb
static const int kArraySize  = 500000;  // about 4Mb
static const int kMinTreeDepth = 4;
static const int kMaxTreeDepth = 16;

typedef struct Node0 *Node;

struct Node0 {
        Node left;
        Node right;
        int i, j;
        Node0(Node l, Node r) { left = l; right = r; }
        Node0() { left = 0; right = 0; }
#       ifndef GC
          ~Node0() { if (left) delete left; if (right) delete right; }
# endif
};

struct GCBench {

        // Nodes used by a tree of a given size
        static int TreeSize(int i) {
                return ((1 << (i + 1)) - 1);
        }

        // Number of iterations to use for a given tree depth
        static int NumIters(int i) {
                return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
        }

        // Build tree top down, assigning to older objects.
        static void Populate(int iDepth, Node thisNode) {
                if (iDepth<=0) {
                        return;
                } else {
                        iDepth--;
#   ifndef GC
                          thisNode->left  = new Node0();
                          thisNode->right = new Node0();
#   else
                          thisNode->left  = new (GC_NEW(Node0)) Node0();
                          thisNode->right = new (GC_NEW(Node0)) Node0();
#   endif
                        Populate (iDepth, thisNode->left);
                        Populate (iDepth, thisNode->right);
                }
        }

        // Build tree bottom-up
        static Node MakeTree(int iDepth) {
                if (iDepth<=0) {
#       ifndef GC
                        return new Node0();
#       else
                        return new (GC_NEW(Node0)) Node0();
#       endif
                } else {
#       ifndef GC
                        return new Node0(MakeTree(iDepth-1),
                                         MakeTree(iDepth-1));
#       else
                        return new (GC_NEW(Node0)) Node0(MakeTree(iDepth-1),
                                            MakeTree(iDepth-1));
#       endif
                }
        }

        static void PrintDiagnostics() {
#if 0
                long lFreeMemory = Runtime.getRuntime().freeMemory();
                long lTotalMemory = Runtime.getRuntime().totalMemory();

                System.out.print(" Total memory available="
                                 + lTotalMemory + " bytes");
                System.out.println("  Free memory=" + lFreeMemory + " bytes");
#endif
        }

        static void TimeConstruction(int depth) {
                long    tStart, tFinish;
                int     iNumIters = NumIters(depth);
                Node    tempTree;

                cout << "Creating " << iNumIters
                     << " trees of depth " << depth << endl;
               
                tStart = currentTime();
                for (int i = 0; i < iNumIters; ++i) {
#   ifndef GC
                          tempTree = new Node0();
#   else
                          tempTree = new (GC_NEW(Node0)) Node0();
#   endif
                        Populate(depth, tempTree);
#          ifndef GC
                          delete tempTree;
#   endif
                        tempTree = 0;
                }
                tFinish = currentTime();
                cout << "\tTop down construction took "
                     << elapsedTime(tFinish - tStart) << " msec" << endl;
                    
                tStart = currentTime();
                for (int i = 0; i < iNumIters; ++i) {
                        tempTree = MakeTree(depth);
#   ifndef GC
                          delete tempTree;
#   endif
                        tempTree = 0;
                }
                tFinish = currentTime();
                cout << "\tBottom up construction took "
                     << elapsedTime(tFinish - tStart) << " msec" << endl;

        }

        void main() {
                Node    root;
                Node    longLivedTree;
                Node    tempTree;
                long    tStart, tFinish;
                long    tElapsed;

#ifdef GC
// GC_full_freq = 30;
GC_enable_incremental();
#endif
                cout << "Garbage Collector Test" << endl;
                cout << " Live storage will peak at "
                     << 2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) +
                        sizeof(double) * kArraySize
                     << " bytes." << endl << endl;
                cout << " Stretching memory with a binary tree of depth "
                     << kStretchTreeDepth << endl;
                PrintDiagnostics();
              
                tStart = currentTime();
               
                // Stretch the memory space quickly
                tempTree = MakeTree(kStretchTreeDepth);
#  ifndef GC
                  delete tempTree;
#  endif
                tempTree = 0;

                // Create a long lived object
                cout << " Creating a long-lived binary tree of depth "
                     << kLongLivedTreeDepth << endl;
#  ifndef GC
                  longLivedTree = new Node0();
#  else
                  longLivedTree = new (GC_NEW(Node0)) Node0();
#  endif
                Populate(kLongLivedTreeDepth, longLivedTree);

                // Create long-lived array, filling half of it
                cout << " Creating a long-lived array of "
                     << kArraySize << " doubles" << endl;
#  ifndef GC
                  double *array = new double[kArraySize];
#  else
                  double *array = (double *)
    GC_MALLOC_ATOMIC(sizeof(double) * kArraySize);
#  endif
                for (int i = 0; i < kArraySize/2; ++i) {
                        array[i] = 1.0/i;
                }
                PrintDiagnostics();

                for (int d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2)
{
                        TimeConstruction(d);
                }

                if (longLivedTree == 0 || array[1000] != 1.0/1000)
                        cout << "Failed" << endl;
                                        // fake reference to LongLivedTree
                                        // and array
                                        // to keep them from being optimized away

                tFinish = currentTime();
                tElapsed = elapsedTime(tFinish-tStart);
                PrintDiagnostics();
                cout << "Completed in " << tElapsed << " msec" << endl;
#  ifdef GC
    cout << "Completed " << GC_gc_no << " collections" <<endl;
    cout << "Heap size is " << GC_get_heap_size() << endl;
#  endif
        }
};

main () {
    GCBench x;
    x.main();
}

// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
// Translated to C++ 30 May 1997 by William D Clinger of Northeastern Univ.
//
//      This is no substitute for real applications.  No actual application
//      is likely to behave in exactly this way.  However, this benchmark was
//      designed to be more representative of real applications than other
//      Java GC benchmarks of which we are aware.
//      It attempts to model those properties of allocation requests that
//      are important to current GC techniques.
//      It is designed to be used either to obtain a single overall performance
//      number, or to give a more detailed estimate of how collector
//      performance varies with object lifetimes.  It prints the time
//      required to allocate and collect balanced binary trees of various
//      sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//      allocates roughly the same amount of memory.
//      Two data structures are kept around during the entire process, so
//      that the measured performance is representative of applications
//      that maintain some live in-memory data.  One of these is a tree
//      containing many pointers.  The other is a large array containing
//      double precision floating point numbers.  Both should be of comparable
//      size.
//
//      The results are only really meaningful together with a specification
//      of how much memory was used.  It is possible to trade memory for
//      better time performance.  This benchmark should be run in a 32 MB
//      heap, though we don't currently know how to enforce that uniformly.
//
//      Unlike the original Ellis and Kovac benchmark, we do not attempt
//      measure pause times.  This facility should eventually be added back
//      in.  There are several reasons for omitting it for now.  The original
//      implementation depended on assumptions about the thread scheduler
//      that don't hold uniformly.  The results really measure both the
//      scheduler and GC.  Pause time measurements tend to not fit well with
//      current benchmark suites.  As far as we know, none of the current
//      commercial Java implementations seriously attempt to minimize GC pause
//      times.

#include <new>         // #include <new.h>
#include <iostream>    // #include <iostream.h>
#include <sys/time.h>

#ifdef GC
#include "gc_cpp.h"    // #  include "gc.h"
#endif
#ifdef OGC
#  include "ogc.h"
#endif

using namespace std;

//  These macros were a quick hack for the Macintosh.
//
//  #define currentTime() clock()
//  #define elapsedTime(x) ((1000*(x))/CLOCKS_PER_SEC)

#define currentTime() stats_rtclock()
#define elapsedTime(x) (x)

/* Get the current time in milliseconds */

unsigned
stats_rtclock( void )
{
  struct timeval t;
  struct timezone tz;

  if (gettimeofday( &t, &tz ) == -1)
    return 0;
  return (t.tv_sec * 1000 + t.tv_usec / 1000);
}

static const int kStretchTreeDepth    = 18;      // about 16Mb
static const int kLongLivedTreeDepth  = 16;  // about 4Mb
static const int kArraySize  = 500000;  // about 4Mb
static const int kMinTreeDepth = 4;
static const int kMaxTreeDepth = 16;

struct Node0 {
#       ifdef OGC
          gc_ptr<Node0> left;
          gc_ptr<Node0> right;
          Node0(gc_ptr<Node0> l, gc_ptr<Node0> r) { left = l; right = r; }
# else
          Node0 * left;
          Node0 * right;
          Node0(Node0 *l, Node0 *r) { left = l; right = r; }
# endif
        int i, j;
        Node0() { left = 0; right = 0; }
#       if !defined(GC) && !defined(OGC)
          ~Node0() { if (left) delete left; if (right) delete right; }
# endif
};

#ifdef OGC
typedef gc_ptr<Node0> Node;
#else
typedef struct Node0 *Node;
#endif

struct GCBench {

        // Nodes used by a tree of a given size
        static int TreeSize(int i) {
                return ((1 << (i + 1)) - 1);
        }

        // Number of iterations to use for a given tree depth
        static int NumIters(int i) {
                return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
        }

        // Build tree top down, assigning to older objects.
        static void Populate(int iDepth, Node thisNode) {
                if (iDepth<=0) {
                        return;
                } else {
                        iDepth--;
#   if defined(GC)
                          thisNode->left  = new (GC_NEW(Node0)) Node0();
                          thisNode->right = new (GC_NEW(Node0)) Node0();
#   elif defined(OGC)
                          thisNode->left  = gc_new Node0();
                          thisNode->right = gc_new Node0();
#   else
                          thisNode->left  = new Node0();
                          thisNode->right = new Node0();
#   endif
                        Populate (iDepth, thisNode->left);
                        Populate (iDepth, thisNode->right);
                }
        }

        // Build tree bottom-up
        static Node MakeTree(int iDepth) {
                if (iDepth<=0) {
#       if defined(GC)
                        return new (GC_NEW(Node0)) Node0();
#       elif defined(OGC)
                        return gc_new Node0();
#       else
                        return new Node0();
#       endif
                } else {
#       if defined(GC)
                        return new (GC_NEW(Node0)) Node0(MakeTree(iDepth-1),
                                            MakeTree(iDepth-1));
#       elif defined(OGC)
#   ifdef BROKEN_SMART_PTRS
     Node left = MakeTree(iDepth-1);
     Node right = MakeTree(iDepth-1);
                          return gc_new Node0(left, right);
#   else
                          return gc_new Node0(MakeTree(iDepth-1),
                                            MakeTree(iDepth-1));
#   endif
#       else
                        return new Node0(MakeTree(iDepth-1),
                                         MakeTree(iDepth-1));
#       endif
                }
        }

        static void PrintDiagnostics() {
#if 0
                long lFreeMemory = Runtime.getRuntime().freeMemory();
                long lTotalMemory = Runtime.getRuntime().totalMemory();

                System.out.print(" Total memory available="
                                 + lTotalMemory + " bytes");
                System.out.println("  Free memory=" + lFreeMemory + " bytes");
#endif
        }

        static void TimeConstruction(int depth) {
                long    tStart, tFinish;
                int     iNumIters = NumIters(depth);
                Node    tempTree;

                cout << "Creating " << iNumIters
                     << " trees of depth " << depth << endl;
               
                tStart = currentTime();
                for (int i = 0; i < iNumIters; ++i) {
#   if defined(GC)
                          tempTree = new (GC_NEW(Node0)) Node0();
#   elif defined(OGC)
                          tempTree = gc_new Node0();
#   else
                          tempTree = new Node0();
#   endif
                        Populate(depth, tempTree);
#          if !defined(GC) && !defined(OGC)
                          delete tempTree;
#   endif
                        tempTree = 0;
                }
                tFinish = currentTime();
                cout << "\tTop down construction took "
                     << elapsedTime(tFinish - tStart) << " msec" << endl;
                    
                tStart = currentTime();
                for (int i = 0; i < iNumIters; ++i) {
                        tempTree = MakeTree(depth);
#   if !defined(GC) && !defined(OGC)
                          delete tempTree;
#   endif
                        tempTree = 0;
                }
                tFinish = currentTime();
                cout << "\tBottom up construction took "
                     << elapsedTime(tFinish - tStart) << " msec" << endl;

        }

        void main() {
                Node    root;
                Node    longLivedTree;
                Node    tempTree;
                long    tStart, tFinish;
                long    tElapsed;

#ifdef GC
// GC_full_freq = 30;
GC_enable_incremental();
#endif

#         ifdef OGC
    GC::SetPolicy(100);
#  endif
                cout << "Garbage Collector Test" << endl;
                cout << " Live storage will peak at "
                     << 2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) +
                        sizeof(double) * kArraySize
                     << " bytes." << endl << endl;
                cout << " Stretching memory with a binary tree of depth "
                     << kStretchTreeDepth << endl;
                PrintDiagnostics();
              
                tStart = currentTime();
               
                // Stretch the memory space quickly
                tempTree = MakeTree(kStretchTreeDepth);
#  if !defined(GC) && !defined(OGC)
                  delete tempTree;
#  endif
                tempTree = 0;

                // Create a long lived object
                cout << " Creating a long-lived binary tree of depth "
                     << kLongLivedTreeDepth << endl;
#  if defined(GC)
                  longLivedTree = new (GC_NEW(Node0)) Node0();
#         elif defined(OGC)
                  longLivedTree = gc_new Node0();
#  else
                  longLivedTree = new Node0();
#  endif
                Populate(kLongLivedTreeDepth, longLivedTree);

                // Create long-lived array, filling half of it
                cout << " Creating a long-lived array of "
                     << kArraySize << " doubles" << endl;
#  if defined(GC)
                  double *array = (double *)
    GC_MALLOC(sizeof(double) * kArraySize);
#  else
                  double *array = new double[kArraySize];
#  endif
                for (int i = 0; i < kArraySize/2; ++i) {
                        array[i] = 1.0/i;
                }
                PrintDiagnostics();

                for (int d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2)
{
                        TimeConstruction(d);
                }

                if (longLivedTree == 0 || array[1000] != 1.0/1000)
                        cout << "Failed" << endl;
                                        // fake reference to LongLivedTree
                                        // and array
                                        // to keep them from being optimized away

                tFinish = currentTime();
                tElapsed = elapsedTime(tFinish-tStart);
                PrintDiagnostics();
                cout << "Completed in " << tElapsed << " msec" << endl;
#  ifdef GC
    cout << "Completed " << GC_gc_no << " collections" <<endl;
    cout << "Heap size is " << GC_get_heap_size() << endl;
#  endif
        }
};

main () {
    GCBench x;
    x.main();
}

/*
 * Filename: testGC_01.c 
 *
 *           Test a garbage collection for C language.
 *
 * Compile: gcc -o testGC_01 testGC_01.c -lgc
 *
 * Execute: ./testGC_01
 *
 * See: http://www.hpl.hp.com/personal/Hans_Boehm/gc/simple_example.html
 */

#include "gc.h"
#include <assert.h>
#include <stdio.h>

int main()
{
    int i;

    GC_INIT(); /* Optional on Linux/X86; see below.  */
    for (i = 0; i < 10000000; ++i)
    {
        int **p = (int **) GC_MALLOC(sizeof(int *));
        int *q = (int *) GC_MALLOC_ATOMIC(sizeof(int));
        assert(*p == 0);
        *p = (int *) GC_REALLOC(q, 2 * sizeof(int));
        if (i % 100000 == 0)
            printf("Heap size = %d\n", GC_get_heap_size());
    }

    return 0;
}

// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
// Translated to C++ 30 May 1997 by William D Clinger of Northeastern Univ.
// Translated to C 15 March 2000 by Hans Boehm, now at HP Labs.
//
//      This is no substitute for real applications.  No actual application
//      is likely to behave in exactly this way.  However, this benchmark was
//      designed to be more representative of real applications than other
//      Java GC benchmarks of which we are aware.
//      It attempts to model those properties of allocation requests that
//      are important to current GC techniques.
//      It is designed to be used either to obtain a single overall performance
//      number, or to give a more detailed estimate of how collector
//      performance varies with object lifetimes.  It prints the time
//      required to allocate and collect balanced binary trees of various
//      sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//      allocates roughly the same amount of memory.
//      Two data structures are kept around during the entire process, so
//      that the measured performance is representative of applications
//      that maintain some live in-memory data.  One of these is a tree
//      containing many pointers.  The other is a large array containing
//      double precision floating point numbers.  Both should be of comparable
//      size.
//
//      The results are only really meaningful together with a specification
//      of how much memory was used.  It is possible to trade memory for
//      better time performance.  This benchmark should be run in a 32 MB
//      heap, though we don't currently know how to enforce that uniformly.
//
//      Unlike the original Ellis and Kovac benchmark, we do not attempt
//      measure pause times.  This facility should eventually be added back
//      in.  There are several reasons for omitting it for now.  The original
//      implementation depended on assumptions about the thread scheduler
//      that don't hold uniformly.  The results really measure both the
//      scheduler and GC.  Pause time measurements tend to not fit well with
//      current benchmark suites.  As far as we know, none of the current
//      commercial Java implementations seriously attempt to minimize GC pause
//      times.

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>

#ifdef GC
#  include "gc.h"
#endif

#ifdef PROFIL
  extern void init_profiling();
  extern dump_profile();
#endif

//  These macros were a quick hack for the Macintosh.
//
//  #define currentTime() clock()
//  #define elapsedTime(x) ((1000*(x))/CLOCKS_PER_SEC)

#define currentTime() stats_rtclock()
#define elapsedTime(x) (x)

/* Get the current time in milliseconds */

unsigned
stats_rtclock( void )
{
  struct timeval t;
  struct timezone tz;

  if (gettimeofday( &t, &tz ) == -1)
    return 0;
  return (t.tv_sec * 1000 + t.tv_usec / 1000);
}

static const int kStretchTreeDepth    = 18;      // about 16Mb
static const int kLongLivedTreeDepth  = 16;  // about 4Mb
static const int kArraySize  = 500000;  // about 4Mb
static const int kMinTreeDepth = 4;
static const int kMaxTreeDepth = 16;

typedef struct Node0_struct {
        struct Node0_struct * left;
        struct Node0_struct * right;
        int i, j;
} Node0;

#ifdef HOLES
#   define HOLE() GC_NEW(Node0);
#else
#   define HOLE()
#endif

typedef Node0 *Node;

void init_Node(Node me, Node l, Node r) {
    me -> left = l;
    me -> right = r;
}

#ifndef GC
  void destroy_Node(Node me) {
    if (me -> left) {
 destroy_Node(me -> left);
    }
    if (me -> right) {
 destroy_Node(me -> right);
    }
    free(me);
  }
#endif

// Nodes used by a tree of a given size
static int TreeSize(int i) {
        return ((1 << (i + 1)) - 1);
}

// Number of iterations to use for a given tree depth
static int NumIters(int i) {
        return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
}

// Build tree top down, assigning to older objects.
static void Populate(int iDepth, Node thisNode) {
        if (iDepth<=0) {
                return;
        } else {
                iDepth--;
#  ifdef GC
                  thisNode->left  = GC_NEW(Node0); HOLE();
                  thisNode->right = GC_NEW(Node0); HOLE();
#  else
                  thisNode->left  = calloc(1, sizeof(Node0));
                  thisNode->right = calloc(1, sizeof(Node0));
#  endif
                Populate (iDepth, thisNode->left);
                Populate (iDepth, thisNode->right);
        }
}

// Build tree bottom-up
static Node MakeTree(int iDepth) {
 Node result;
        if (iDepth<=0) {
#     ifndef GC
  result = calloc(1, sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     /* result is implicitly initialized in both cases. */
     return result;
        } else {
     Node left = MakeTree(iDepth-1);
     Node right = MakeTree(iDepth-1);
#     ifndef GC
  result = malloc(sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     init_Node(result, left, right);
     return result;
        }
}

static void PrintDiagnostics() {
#if 0
        long lFreeMemory = Runtime.getRuntime().freeMemory();
        long lTotalMemory = Runtime.getRuntime().totalMemory();

        System.out.print(" Total memory available="
                         + lTotalMemory + " bytes");
        System.out.println("  Free memory=" + lFreeMemory + " bytes");
#endif
}

static void TimeConstruction(int depth) {
        long    tStart, tFinish;
        int     iNumIters = NumIters(depth);
        Node    tempTree;
 int  i;

 printf("Creating %d trees of depth %d\n", iNumIters, depth);
       
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
#  ifndef GC
                  tempTree = calloc(1, sizeof(Node0));
#  else
                  tempTree = GC_NEW(Node0);
#  endif
                Populate(depth, tempTree);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\tTop down construction took %d msec\n",
               elapsedTime(tFinish - tStart));
            
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
                tempTree = MakeTree(depth);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\tBottom up construction took %d msec\n",
               elapsedTime(tFinish - tStart));

}

int main() {
        Node    root;
        Node    longLivedTree;
        Node    tempTree;
        long    tStart, tFinish;
        long    tElapsed;
   int i, d;
 double  *array;

#ifdef GC
 // GC_full_freq = 30;
 // GC_free_space_divisor = 16;
 // GC_enable_incremental();
#endif
 printf("Garbage Collector Test\n");
  printf(" Live storage will peak at %d bytes.\n\n",
               2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) +
               sizeof(double) * kArraySize);
        printf(" Stretching memory with a binary tree of depth %d\n",
               kStretchTreeDepth);
        PrintDiagnostics();
# ifdef PROFIL
     init_profiling();
# endif
      
        tStart = currentTime();
       
        // Stretch the memory space quickly
        tempTree = MakeTree(kStretchTreeDepth);
# ifndef GC
          destroy_Node(tempTree);
# endif
        tempTree = 0;

        // Create a long lived object
        printf(" Creating a long-lived binary tree of depth %d\n",
               kLongLivedTreeDepth);
# ifndef GC
          longLivedTree = calloc(1, sizeof(Node0));
# else
          longLivedTree = GC_NEW(Node0);
# endif
        Populate(kLongLivedTreeDepth, longLivedTree);

        // Create long-lived array, filling half of it
 printf(" Creating a long-lived array of %d doubles\n", kArraySize);
# ifndef GC
          array = malloc(kArraySize * sizeof(double));
# else
#   ifndef NO_PTRFREE
            array = GC_MALLOC_ATOMIC(sizeof(double) * kArraySize);
#   else
            array = GC_MALLOC(sizeof(double) * kArraySize);
#   endif
# endif
        for (i = 0; i < kArraySize/2; ++i) {
                array[i] = 1.0/i;
        }
        PrintDiagnostics();

        for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) {
                TimeConstruction(d);
        }

        if (longLivedTree == 0 || array[1000] != 1.0/1000)
  fprintf(stderr, "Failed\n");
                                // fake reference to LongLivedTree
                                // and array
                                // to keep them from being optimized away

        tFinish = currentTime();
        tElapsed = elapsedTime(tFinish-tStart);
        PrintDiagnostics();
        printf("Completed in %d msec\n", tElapsed);
# ifdef GC
   printf("Completed %d collections\n", GC_gc_no);
   printf("Heap size is %d\n", GC_get_heap_size());
#       endif
# ifdef PROFIL
   dump_profile();
# endif
}

// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
// Translated to C++ 30 May 1997 by William D Clinger of Northeastern Univ.
// Translated to C 15 March 2000 by Hans Boehm, now at HP Labs.
// Adapted to run NTHREADS client threads concurrently.  Each
// thread executes the original benchmark.  12 June 2000  by Hans Boehm.
//
//      This is no substitute for real applications.  No actual application
//      is likely to behave in exactly this way.  However, this benchmark was
//      designed to be more representative of real applications than other
//      Java GC benchmarks of which we are aware.
//      It attempts to model those properties of allocation requests that
//      are important to current GC techniques.
//      It is designed to be used either to obtain a single overall performance
//      number, or to give a more detailed estimate of how collector
//      performance varies with object lifetimes.  It prints the time
//      required to allocate and collect balanced binary trees of various
//      sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//      allocates roughly the same amount of memory.
//      Two data structures are kept around during the entire process, so
//      that the measured performance is representative of applications
//      that maintain some live in-memory data.  One of these is a tree
//      containing many pointers.  The other is a large array containing
//      double precision floating point numbers.  Both should be of comparable
//      size.
//
//      The results are only really meaningful together with a specification
//      of how much memory was used.  It is possible to trade memory for
//      better time performance.  This benchmark should be run in a 32 MB
//      heap, though we don't currently know how to enforce that uniformly.
//
//      Unlike the original Ellis and Kovac benchmark, we do not attempt
//      measure pause times.  This facility should eventually be added back
//      in.  There are several reasons for omitting it for now.  The original
//      implementation depended on assumptions about the thread scheduler
//      that don't hold uniformly.  The results really measure both the
//      scheduler and GC.  Pause time measurements tend to not fit well with
//      current benchmark suites.  As far as we know, none of the current
//      commercial Java implementations seriously attempt to minimize GC pause
//      times.

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <pthread.h>

#ifdef GC
#  ifndef LINUX_THREADS
#     define LINUX_THREADS
#  endif
#  ifndef _REENTRANT
#     define _REENTRANT
#  endif
#  ifdef LOCAL
#    define GC_REDIRECT_TO_LOCAL
#    include "gc_local_alloc.h"
#  endif
#  include "gc.h"
#endif

#ifndef NTHREADS
#   define NTHREADS 1
#endif

#ifdef PROFIL
  extern void init_profiling();
  extern dump_profile();
#endif

//  These macros were a quick hack for the Macintosh.
//
//  #define currentTime() clock()
//  #define elapsedTime(x) ((1000*(x))/CLOCKS_PER_SEC)

#define currentTime() stats_rtclock()
#define elapsedTime(x) (x)

/* Get the current time in milliseconds */

unsigned
stats_rtclock( void )
{
  struct timeval t;
  struct timezone tz;

  if (gettimeofday( &t, &tz ) == -1)
    return 0;
  return (t.tv_sec * 1000 + t.tv_usec / 1000);
}

static const int kStretchTreeDepth    = 18;      // about 16Mb
static const int kLongLivedTreeDepth  = 16;  // about 4Mb
static const int kArraySize  = 500000;  // about 4Mb
static const int kMinTreeDepth = 4;
static const int kMaxTreeDepth = 16;

typedef struct Node0_struct {
        struct Node0_struct * left;
        struct Node0_struct * right;
        int i, j;
} Node0;

#ifdef HOLES
#   define HOLE() GC_NEW(Node0);
#else
#   define HOLE()
#endif

typedef Node0 *Node;

void init_Node(Node me, Node l, Node r) {
    me -> left = l;
    me -> right = r;
}

#ifndef GC
  void destroy_Node(Node me) {
    if (me -> left) {
 destroy_Node(me -> left);
    }
    if (me -> right) {
 destroy_Node(me -> right);
    }
    free(me);
  }
#endif

// Nodes used by a tree of a given size
static int TreeSize(int i) {
        return ((1 << (i + 1)) - 1);
}

// Number of iterations to use for a given tree depth
static int NumIters(int i) {
        return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
}

// Build tree top down, assigning to older objects.
static void Populate(int iDepth, Node thisNode) {
        if (iDepth<=0) {
                return;
        } else {
                iDepth--;
#  ifdef GC
                  thisNode->left  = GC_NEW(Node0); HOLE();
                  thisNode->right = GC_NEW(Node0); HOLE();
#  else
                  thisNode->left  = calloc(1, sizeof(Node0));
                  thisNode->right = calloc(1, sizeof(Node0));
#  endif
                Populate (iDepth, thisNode->left);
                Populate (iDepth, thisNode->right);
        }
}

// Build tree bottom-up
static Node MakeTree(int iDepth) {
 Node result;
        if (iDepth<=0) {
#     ifndef GC
  result = calloc(1, sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     /* result is implicitly initialized in both cases. */
     return result;
        } else {
     Node left = MakeTree(iDepth-1);
     Node right = MakeTree(iDepth-1);
#     ifndef GC
  result = malloc(sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     init_Node(result, left, right);
     return result;
        }
}

static void PrintDiagnostics() {
#if 0
        long lFreeMemory = Runtime.getRuntime().freeMemory();
        long lTotalMemory = Runtime.getRuntime().totalMemory();

        System.out.print(" Total memory available="
                         + lTotalMemory + " bytes");
        System.out.println("  Free memory=" + lFreeMemory + " bytes");
#endif
}

static void TimeConstruction(int depth) {
        long    tStart, tFinish;
        int     iNumIters = NumIters(depth);
        Node    tempTree;
 int  i;

 printf("0x%x: Creating %d trees of depth %d\n", pthread_self(), iNumIters, depth);
       
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
#  ifndef GC
                  tempTree = calloc(1, sizeof(Node0));
#  else
                  tempTree = GC_NEW(Node0);
#  endif
                Populate(depth, tempTree);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\t0x%x: Top down construction took %d msec\n",
               pthread_self(), elapsedTime(tFinish - tStart));
            
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
                tempTree = MakeTree(depth);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\t0x%x: Bottom up construction took %d msec\n",
               pthread_self(), elapsedTime(tFinish - tStart));

}

void * run_one_test(void * arg) {
 int d;
        for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) {
                TimeConstruction(d);
        }
}

int main() {
        Node    root;
        Node    longLivedTree;
        Node    tempTree;
        long    tStart, tFinish;
        long    tElapsed;
   int i;
 double  *array;

#ifdef GC
 // GC_full_freq = 30;
 // GC_free_space_divisor = 16;
 // GC_enable_incremental();
#endif
#       if defined(GC) && defined(LOCAL)
   GC_thr_init();
#   endif
 printf("Garbage Collector Test\n");
  printf(" Live storage will peak at %d bytes.\n\n",
               2 * sizeof(Node0) * TreeSize(kLongLivedTreeDepth) +
               sizeof(double) * kArraySize);
        printf(" Stretching memory with a binary tree of depth %d\n",
               kStretchTreeDepth);
        PrintDiagnostics();
# ifdef PROFIL
     init_profiling();
# endif
      
        tStart = currentTime();
       
        // Stretch the memory space quickly
        tempTree = MakeTree(kStretchTreeDepth);
# ifndef GC
          destroy_Node(tempTree);
# endif
        tempTree = 0;

        // Create a long lived object
        printf(" Creating a long-lived binary tree of depth %d\n",
               kLongLivedTreeDepth);
# ifndef GC
          longLivedTree = calloc(1, sizeof(Node0));
# else
          longLivedTree = GC_NEW(Node0);
# endif
        Populate(kLongLivedTreeDepth, longLivedTree);

        // Create long-lived array, filling half of it
 printf(" Creating a long-lived array of %d doubles\n", kArraySize);
# ifndef GC
          array = malloc(kArraySize * sizeof(double));
# else
#   ifndef NO_PTRFREE
            array = GC_MALLOC_ATOMIC(sizeof(double) * kArraySize);
#   else
            array = GC_MALLOC(sizeof(double) * kArraySize);
#   endif
# endif
        for (i = 0; i < kArraySize/2; ++i) {
                array[i] = 1.0/i;
        }

        {
   pthread_t thread[NTHREADS];
   for (i = 1; i < NTHREADS; ++i) {
         int code;

     if ((code = pthread_create(thread+i, 0, run_one_test, 0)) != 0) {
           fprintf(stderr, "Thread creation failed %u\n", code);
       exit(1);
     }
   }
   /* We use the main thread to run one test.  This allows */
   /* profiling to work, for example.    */
   run_one_test(0);
   for (i = 1; i < NTHREADS; ++i) {
         int code;
     if ((code = pthread_join(thread[i], 0)) != 0) {
         fprintf(stderr, "Thread join failed %u\n", code);
           }
    }
        }
        PrintDiagnostics();

        if (longLivedTree == 0 || array[1000] != 1.0/1000)
  fprintf(stderr, "Failed\n");
                                // fake reference to LongLivedTree
                                // and array
                                // to keep them from being optimized away

        tFinish = currentTime();
        tElapsed = elapsedTime(tFinish-tStart);
        PrintDiagnostics();
        printf("Completed in %d msec\n", tElapsed);
# ifdef GC
   printf("Completed %d collections\n", GC_gc_no);
   printf("Heap size is %d\n", GC_get_heap_size());
#       endif
# ifdef PROFIL
   dump_profile();
# endif
}

// This is version 2 of the multithreaded GC Bench.
// Heap expansion is handled differently from version 1, in an attempt
// to make scalability measurements more meaningful.  The version with
// N threads now immediately expands the heap to N*32MB.
//
// To run this with BDWGC versions 6 and later with thread local allocation,
// define GC and LOCAL.  Without thread-local allocation, define just GC.
// To run it with the University of Tokyo scalable GC,
// define SGC.  To run it with malloc and explicit deallocation, define
// none of these.  (This should also work for Hoard.)
//
// Note that defining GC or SGC removes the explicit deallocation passes,
// which seems fair.
//
// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
// Translated to C++ 30 May 1997 by William D Clinger of Northeastern Univ.
// Translated to C 15 March 2000 by Hans Boehm, now at HP Labs.
// Adapted to run NTHREADS client threads concurrently.  Each
// thread executes the original benchmark.  12 June 2000  by Hans Boehm.
// Changed heap expansion rule, and made the number of threads run-time
// configurable.  25 Oct 2000 by Hans Boehm.
//
//      This is no substitute for real applications.  No actual application
//      is likely to behave in exactly this way.  However, this benchmark was
//      designed to be more representative of real applications than other
//      Java GC benchmarks of which we were aware at the time.
//      It still doesn't seem too bad for something this small.
//      It attempts to model those properties of allocation requests that
//      are important to current GC techniques.
//      It is designed to be used either to obtain a single overall performance
//      number, or to give a more detailed estimate of how collector
//      performance varies with object lifetimes.  It prints the time
//      required to allocate and collect balanced binary trees of various
//      sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//      allocates roughly the same amount of memory.
//      Two data structures are kept around during the entire process, so
//      that the measured performance is representative of applications
//      that maintain some live in-memory data.  One of these is a tree
//      containing many pointers.  The other is a large array containing
//      double precision floating point numbers.  Both should be of comparable
//      size.
//
//      The results are only really meaningful together with a specification
//      of how much memory was used.  This versions of the benchmark tries
//      to preallocate a sufficiently large heap that expansion should not be
//      needed.
//
//      Unlike the original Ellis and Kovac benchmark, we do not attempt
//      measure pause times.  This facility should eventually be added back
//      in.  There are several reasons for omitting it for now.  The original
//      implementation depended on assumptions about the thread scheduler
//      that don't hold uniformly.  The results really measure both the
//      scheduler and GC.  Pause time measurements tend to not fit well with
//      current benchmark suites.  As far as we know, none of the current
//      commercial Java implementations seriously attempt to minimize GC pause
//      times.
//
//      Since this benchmark has recently been more widely used, some
//      anomalous behavious has been uncovered.  The user should be aware
//      of this:
//      1) Nearly all objects are of the same size.  This benchmark is
//         not useful for analyzing fragmentation behavior.  It is unclear
//         whether this is an issue for well-designed allocators.
//      2) Unless HOLES is defined, it tends to drop consecutively allocated
//         memory at the same time.  Many real applications do exhibit this
//         phenomenon, but probably not to this extent.  (Defining HOLES tends
//         to move the benchmark to the opposite extreme.)
//      3) It appears harder to predict object lifetimes than for most real
//         Java programs (see T. Harris, "Dynamic adptive pre-tenuring",
//         ISMM '00).

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <pthread.h>

#ifdef GC
#  ifndef LINUX_THREADS
#     define LINUX_THREADS
#  endif
#  ifndef _REENTRANT
#     define _REENTRANT
#  endif
#  ifdef LOCAL
#    define GC_REDIRECT_TO_LOCAL
#    include "gc_local_alloc.h"
#  endif
#  include "gc.h"
#endif
#ifdef SGC
#  include "sgc.h"
#  define GC
#  define pthread_create GC_pthread_create
#  define pthread_join GC_pthread_join
#endif

#define MAX_NTHREADS 1024

int nthreads = 0;

#ifdef PROFIL
  extern void init_profiling();
  extern dump_profile();
#endif

//  These macros were a quick hack for the Macintosh.
//
//  #define currentTime() clock()
//  #define elapsedTime(x) ((1000*(x))/CLOCKS_PER_SEC)

#define currentTime() stats_rtclock()
#define elapsedTime(x) (x)

/* Get the current time in milliseconds */

unsigned
stats_rtclock( void )
{
  struct timeval t;
  struct timezone tz;

  if (gettimeofday( &t, &tz ) == -1)
    return 0;
  return (t.tv_sec * 1000 + t.tv_usec / 1000);
}

static const int kStretchTreeDepth    = 18;      // about 16Mb
static const int kLongLivedTreeDepth  = 16;  // about 4Mb
static const int kArraySize  = 500000;  // about 4Mb
static const int kMinTreeDepth = 4;
static const int kMaxTreeDepth = 16;

typedef struct Node0_struct {
        struct Node0_struct * left;
        struct Node0_struct * right;
        int i, j;
} Node0;

#ifdef HOLES
#   define HOLE() GC_NEW(Node0);
#else
#   define HOLE()
#endif

typedef Node0 *Node;

void init_Node(Node me, Node l, Node r) {
    me -> left = l;
    me -> right = r;
}

#ifndef GC
  void destroy_Node(Node me) {
    if (me -> left) {
 destroy_Node(me -> left);
    }
    if (me -> right) {
 destroy_Node(me -> right);
    }
    free(me);
  }
#endif

// Nodes used by a tree of a given size
static int TreeSize(int i) {
        return ((1 << (i + 1)) - 1);
}

// Number of iterations to use for a given tree depth
static int NumIters(int i) {
        return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
}

// Build tree top down, assigning to older objects.
static void Populate(int iDepth, Node thisNode) {
        if (iDepth<=0) {
                return;
        } else {
                iDepth--;
#  ifdef GC
                  thisNode->left  = GC_NEW(Node0); HOLE();
                  thisNode->right = GC_NEW(Node0); HOLE();
#  else
                  thisNode->left  = calloc(1, sizeof(Node0));
                  thisNode->right = calloc(1, sizeof(Node0));
#  endif
                Populate (iDepth, thisNode->left);
                Populate (iDepth, thisNode->right);
        }
}

// Build tree bottom-up
static Node MakeTree(int iDepth) {
 Node result;
        if (iDepth<=0) {
#     ifndef GC
  result = calloc(1, sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     /* result is implicitly initialized in both cases. */
     return result;
        } else {
     Node left = MakeTree(iDepth-1);
     Node right = MakeTree(iDepth-1);
#     ifndef GC
  result = malloc(sizeof(Node0));
#     else
  result = GC_NEW(Node0); HOLE();
#     endif
     init_Node(result, left, right);
     return result;
        }
}

static void PrintDiagnostics() {
#if 0
        long lFreeMemory = Runtime.getRuntime().freeMemory();
        long lTotalMemory = Runtime.getRuntime().totalMemory();

        System.out.print(" Total memory available="
                         + lTotalMemory + " bytes");
        System.out.println("  Free memory=" + lFreeMemory + " bytes");
#endif
}

static void TimeConstruction(int depth) {
        long    tStart, tFinish;
        int     iNumIters = NumIters(depth);
        Node    tempTree;
 int  i;

 printf("0x%x: Creating %d trees of depth %d\n", pthread_self(), iNumIters, depth);
       
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
#  ifndef GC
                  tempTree = calloc(1, sizeof(Node0));
#  else
                  tempTree = GC_NEW(Node0);
#  endif
                Populate(depth, tempTree);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\t0x%x: Top down construction took %d msec\n",
               pthread_self(), elapsedTime(tFinish - tStart));
            
        tStart = currentTime();
        for (i = 0; i < iNumIters; ++i) {
                tempTree = MakeTree(depth);
#  ifndef GC
                  destroy_Node(tempTree);
#  endif
                tempTree = 0;
        }
        tFinish = currentTime();
        printf("\t0x%x: Bottom up construction took %d msec\n",
               pthread_self(), elapsedTime(tFinish - tStart));

}

void * run_one_test(void * arg) {
 int d, i;
        Node    longLivedTree;
 double  *array;
 /* size_t initial_bytes = GC_get_total_bytes(); */

        // Create a long lived object
        printf(" Creating a long-lived binary tree of depth %d\n",
               kLongLivedTreeDepth);
# ifndef GC
          longLivedTree = calloc(1, sizeof(Node0));
# else
          longLivedTree = GC_NEW(Node0);
# endif
        Populate(kLongLivedTreeDepth, longLivedTree);

        // Create long-lived array, filling half of it
 printf(" Creating a long-lived array of %d doubles\n", kArraySize);
# ifndef GC
          array = malloc(kArraySize * sizeof(double));
# else
#   ifndef NO_PTRFREE
            array = GC_MALLOC_ATOMIC(sizeof(double) * kArraySize);
#   else
            array = GC_MALLOC(sizeof(double) * kArraySize);
#   endif
# endif
        for (i = 0; i < kArraySize/2; ++i) {
                array[i] = 1.0/i;
        }

        for (d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) {
                TimeConstruction(d);
        }
 /* printf("Allocated %ld bytes before start, %ld after\n",
  initial_bytes, GC_get_total_bytes() - initial_bytes); */
        if (longLivedTree->left -> right == 0 || array[1000] != 1.0/1000)
  fprintf(stderr, "Failed\n");
                                // fake reference to LongLivedTree
                                // and array
                                // to keep them from being optimized away

}

int main(int argc, char **argv) {
        Node    root;
        Node    tempTree[MAX_NTHREADS];
        long    tStart, tFinish;
        long    tElapsed;
   int i;
# ifdef SGC
   SGC_attr_t attr;
# endif

 if (1 == argc) {
     nthreads = 1;
 } else if (2 == argc) {
     nthreads = atoi(argv[1]);
     if (nthreads < 1 || nthreads > MAX_NTHREADS) {
  fprintf(stderr, "Invalid # of threads argument\n");
  exit(1);
     }
 } else {
     fprintf(stderr, "Usage: %s [# of threads]\n");
     exit(1);
 }
#       if defined(SGC)
   /* The University of Tokyo collector needs explicit */
   /* initialization.     */
   SGC_attr_init(&attr);
   SGC_init(nthreads, &attr);
#   endif
#ifdef GC
 // GC_full_freq = 30;
 // GC_free_space_divisor = 16;
 // GC_enable_incremental();
#endif
 printf("Garbage Collector Test\n");
  printf(" Live storage will peak at %d bytes or less .\n\n",
               2 * sizeof(Node0) * nthreads
          * (TreeSize(kLongLivedTreeDepth) + TreeSize(kMaxTreeDepth))
               + sizeof(double) * kArraySize);
        PrintDiagnostics();
       
# ifdef GC
   /* GC_expand_hp fails with empty heap */
   GC_malloc(1);
   GC_expand_hp(32*1024*1024*nthreads);
# endif

# ifdef PROFIL
     init_profiling();
# endif
      
        tStart = currentTime();
        {
   pthread_t thread[MAX_NTHREADS];
   for (i = 1; i < nthreads; ++i) {
         int code;

     if ((code = pthread_create(thread+i, 0, run_one_test, 0)) != 0) {
           fprintf(stderr, "Thread creation failed %u\n", code);
       exit(1);
     }
   }
   /* We use the main thread to run one test.  This allows */
   /* profiling to work, for example.    */
   run_one_test(0);
   for (i = 1; i < nthreads; ++i) {
         int code;
     if ((code = pthread_join(thread[i], 0)) != 0) {
         fprintf(stderr, "Thread join failed %u\n", code);
           }
    }
        }
        PrintDiagnostics();

        tFinish = currentTime();
        tElapsed = elapsedTime(tFinish-tStart);
        PrintDiagnostics();
        printf("Completed in %d msec\n", tElapsed);
# ifdef GC
   printf("Completed %d collections\n", GC_gc_no);
   printf("Heap size is %d\n", GC_get_heap_size());
#       endif
# ifdef PROFIL
   dump_profile();
# endif
        return 0;
}

#include <afxwin.h>
#include <wchar.h>
#include <cmath>

#ifdef MINIMAL

// Stub out non-critical CRT initialization functions
extern "C" void _setenvp() { }
extern "C" void _setargv() { }

// Define a window class derived from CWnd
class CHelloWindow : public CWnd
{
public:
    CHelloWindow()
    {
        CreateEx(WS_EX_CLIENTEDGE,
                      AfxRegisterWndClass(0, ::LoadCursor(NULL, IDC_ARROW),
                      (HBRUSH)(COLOR_WINDOW+1)),
                      _T("Hello World!"),
                      WS_OVERLAPPEDWINDOW,
                      CW_USEDEFAULT,
                      CW_USEDEFAULT,
                      400,       /// CW_USEDEFAULT,
                      220,       /// CW_USEDEFAULT,
                      NULL,
                      NULL,
                      0);
    }
};

#else

// Define a window class derived from CFrameWnd
class CHelloWindow : public CFrameWnd
{
public:
    CHelloWindow()
    { Create(NULL, _T("MFC, 안녕?"), WS_OVERLAPPEDWINDOW, rectDefault); }
    afx_msg void OnPaint();
    DECLARE_MESSAGE_MAP();
};

BEGIN_MESSAGE_MAP(CHelloWindow, CFrameWnd)
    ON_WM_PAINT()
END_MESSAGE_MAP()

void CHelloWindow::OnPaint() {
    CPaintDC dc(this);
    CString msg = "간단한 MFC 응용프로그램";
    dc.TextOut(10, 5, msg);
    wchar_t temp[120];
    double x, y;
    int xpos, ypos;
    x = 1.2;
    y = 5.1;
    swprintf(temp, 100, L"    합:  %wg + %wg = %wg", x, y, x + y);
    xpos = 75;
    ypos = 40;
    dc.TextOut(xpos, ypos, temp);
    swprintf(temp, 100, L"    차:  %wg - %wg = %wg", x, y, x - y);
    ypos += 20;
    dc.TextOut(xpos, ypos, temp);
    swprintf(temp, 100, L"    곱:  %wg * %wg = %wg", x, y, x * y);
    ypos += 20;
    dc.TextOut(xpos, ypos, temp);
    if (y != 0.0) {
        swprintf(temp, 100, L"    몫:  %wg / %wg = %wg", x, y, x / y);
        ypos += 20;
        dc.TextOut(xpos, ypos, temp);
    }
    if (x > 0.0) {
        swprintf(temp, 100, L"멱승:  %wg**%wg = %wg", x, y, pow(x, y));
        ypos += 20;
        dc.TextOut(xpos, ypos, temp);
    }
    if (x > 0.0 && x != 0.0 && y > 0.0) {
        swprintf(temp, 100, L"로그:  log_%wg( %wg ) = %wg", x, y, log(y)/log(x));
        ypos += 20;
        dc.TextOut(xpos, ypos, temp);
    }
}

#endif

// Define an application class derived from CWinApp
class CHelloApp : public CWinApp
{
public:
    virtual BOOL InitInstance()
    {
        m_pMainWnd = new CHelloWindow();
        m_pMainWnd->ShowWindow(m_nCmdShow);
        m_pMainWnd->SetWindowPos(NULL, 0, 0, 400, 220, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
        m_pMainWnd->UpdateWindow();
        return TRUE;
    }
};

CHelloApp HelloApp;  // HelloApp's constructor initializes and runs the app

#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <tchar.h>
#include <cmath>
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

// 전역 변수(Global variables)

// 주요 창의 클래스 명
static TCHAR szWindowClass[] = _T("win32sample");

// 애플리케이션의 주요 창의 제목
/// static TCHAR szTitle[] = _T("Win32 Guided Tour Application");
static TCHAR szTitle[] = _T("Win32 SDK 간단 예제");

 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR szCmdLine, int iCmdShow)
{
    static char szAppName[] = "ExSdk";
    HWND   hwnd;
    MSG    msg;
    WNDCLASSEX  wndclass;
 
    wndclass.cbSize  = sizeof (wndclass);
    wndclass.style = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc  = WndProc;
    wndclass.cbClsExtra    = 0;
    wndclass.cbWndExtra    = 0;
    wndclass.hInstance    = hInstance;
    wndclass.hIcon    = LoadIcon (NULL, IDI_APPLICATION);
    wndclass.hCursor  = LoadCursor (NULL, IDC_ARROW);
    wndclass.hbrBackground  = (HBRUSH) GetStockObject(WHITE_BRUSH);
    wndclass.lpszMenuName  = NULL;
    wndclass.lpszClassName = szWindowClass;
    wndclass.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
 
    RegisterClassEx( &wndclass );
 
    hwnd = CreateWindow(szWindowClass,
                  szTitle,,
                  WS_OVERLAPPEDWINDOW,
                  CW_USEDEFAULT,
                  CW_USEDEFAULT,
                  500,    /// CW_USEDEFAULT,
                  200,    /// CW_USEDEFAULT,
                  NULL,
                  NULL,
                  hInstance,
                  NULL);
 
    ShowWindow(hwnd, iCmdShow);
    UpdateWindow(hwnd);
 
    while (GetMessage(&msg, NULL, 0,0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
    HDC          hdc;
    PAINTSTRUCT  ps;
    wchar_t temp[100];
    double x, y;
    int ypos;
 
    switch (iMsg)
    {
        case WM_CREATE:
            return 0;
        case WM_PAINT:
            hdc = BeginPaint(hwnd, &ps);
            wcscpy_s(temp, 100, L"SDK로 제작한 간단한 Win32 응용프로그램");
            TextOut(hdc, 10, 5, temp, _tcslen(temp));
            x = 1.2;
            y = 5.1;
            swprintf(temp, 100, L"    합:  %wg + %wg = %wg", x, y, x + y);
            ypos = 35;
            TextOut(hdc, 15, ypos, temp, _tcslen(temp));
            swprintf(temp, 100, L"    차:  %wg - %wg = %wg", x, y, x - y);
            ypos += 20;
            TextOut(hdc, 15, ypos, temp, _tcslen(temp));
            swprintf(temp, 100, L"    곱:  %wg * %wg = %wg", x, y, x * y);
            ypos += 20;
            TextOut(hdc, 15, ypos, temp, _tcslen(temp));
            if (y != 0.0) {
                swprintf(temp, 100, L"    몫:  %wg / %wg = %wg", x, y, x / y);
                ypos += 20;
                TextOut(hdc, 15, ypos, temp, _tcslen(temp));
            }
            if (x > 0.0) {
                swprintf(temp, 100, L"멱승:  %wg**%wg = %wg", x, y, pow(x, y));
                ypos += 20;
                TextOut(hdc, 15, ypos, temp, _tcslen(temp));
            }
            if (x > 0.0 && x != 0.0 && y > 0.0) {
                swprintf(temp, 100, L"로그:  log_%wg( %wg ) = %wg", x, y, log(y)/log(x));
                ypos += 20;
                TextOut(hdc, 15, ypos, temp, _tcslen(temp));
            }
            EndPaint(hwnd, &ps);
            return 0;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
 
    return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

#include <iostream>

int wmain(int argc, const wchar_t *argv[])
{
    for (int i = 0; i < argc; i++) {
        printf("%d: %ws\n", i, argv[i]);
    }

    if (argc == 3)
    {
        double x;
        double y;
        x = _wtof(argv[1]);
        y = _wtof(argv[2]);
        printf( "  %s: %g + %g = %g\n", "합", x, y, x + y);
        printf( "  차: %g - %g = %g\n", x, y, x - y);
        printf( "  곱: %g * %g = %g\n", x, y, x * y);
        if (y != 0.0) 
        {
            printf( "  몫: %g / %g = %g\n", x, y, x / y);
        }
        if (x > 0.0) 
        {
            printf( "멱승: %g**%g = %g\n", x, y, pow(x,y));
        }
        if (x > 0.0 && x != 1.0 && y > 0.0) 
        {
            printf( "로그: log_%g( %g ) = %g\n", x, y, log(y)/log(x));
        }
    }

    return 0;
}

/*
Execute & Output:
Prompt> hello_a 1.2 5.4
0: hello_a
1: 1.2
2: 5.4
  합: 1.2 + 5.4 = 6.6
  차: 1.2 - 5.4 = -4.2
  곱: 1.2 * 5.4 = 6.48
  몫: 1.2 / 5.4 = 0.222222
멱승: 1.2**5.4 = 2.67657
로그: log_1.2( 5.4 ) = 9.24959
*/

#include <iostream>
#include <atlstr.h>   // required for  _tmain()

int _tmain(int argc, const char *argv[])
{
    for (int i = 0; i < argc; i++) {
        printf("%d: %s\n", i, argv[i]);
    }

    if (argc == 3)
    {
        double x;
        double y;
    x = atof(argv[1]);
    y = atof(argv[2]);
       printf( "  %s: %g + %g = %g\n", "합", x, y, x + y);
       printf( "  차: %g - %g = %g\n", x, y, x - y);
       printf( "  곱: %g * %g = %g\n", x, y, x * y);
        if (y != 0.0) 
        {
            printf( "  몫: %g / %g = %g\n", x, y, x / y);
        }
        if (x > 0.0) 
        {
            printf( "멱승: %g**%g = %g\n", x, y, pow(x,y));
        }
        if (x > 0.0 && x != 1.0 && y > 0.0) 
        {
            printf( "로그: log_%g( %g ) = %g\n", x, y, log(y)/log(x));
        }
    }

    return 0;
}

/*
Execute & Output:
Prompt> hello_b 1.2 5.4
0: hello_b
1: 1.2
2: 5.4
  합: 1.2 + 5.4 = 6.6
  차: 1.2 - 5.4 = -4.2
  곱: 1.2 * 5.4 = 6.48
  몫: 1.2 / 5.4 = 0.222222
멱승: 1.2**5.4 = 2.67657
로그: log_1.2( 5.4 ) = 9.24959
*/

#include <iostream>

int main(int argc, const char *argv[])
{
    for (int i = 0; i < argc; i++) {
        printf("%d: %s\n", i, argv[i]);
    }

    if (argc == 3)
    {
        double x;
        double y;
        x = atof(argv[1]);
        y = atof(argv[2]);
        printf( "  %s: %g + %g = %g\n", "합", x, y, x + y);
        printf( "  차: %g - %g = %g\n", x, y, x - y);
        printf( "  곱: %g * %g = %g\n", x, y, x * y);
        if (y != 0.0) 
        {
            printf( "  몫: %g / %g = %g\n", x, y, x / y);
        }
        if (x > 0.0) 
        {
            printf( "멱승: %g**%g = %g\n", x, y, pow(x,y));
        }
        if (x > 0.0 && x != 1.0 && y > 0.0) 
        {
            printf( "로그: log_%g( %g ) = %g\n", x, y, log(y)/log(x));
        }
    }

    return 0;
}

/*
Execute & Output:
Prompt> hello_c 1.2 5.4
0: hello_c
1: 1.2
2: 5.4
  합: 1.2 + 5.4 = 6.6
  차: 1.2 - 5.4 = -4.2
  곱: 1.2 * 5.4 = 6.48
  몫: 1.2 / 5.4 = 0.222222
멱승: 1.2**5.4 = 2.67657
로그: log_1.2( 5.4 ) = 9.24959
*/

#include <iostream>

int main(int argc, const char *argv[])
{
    for (int i = 0; i < argc; i++) {
        printf("%d: %s\n", i, argv[i]);
    }

    if (argc == 3)
    {
        double x;
        double y;
        x = atof(argv[1]);
        y = atof(argv[2]);

        wprintf( L"  %S: %g + %g = %g\n", "합", x, y, x + y);
        wprintf( L"  %S: %g - %g = %g\n", "차", x, y, x - y);
        wprintf( L"  %S: %g * %g = %g\n", "곱",x, y, x * y);
        if (y != 0.0) 
        {
            wprintf( L"  %S: %g / %g = %g\n", "몫", x, y, x / y);
        }
        if (x > 0.0) 
        {
            wprintf( L"%S; %g**%g = %g\n", "멱승", x, y, pow(x,y));
        }
        if (x > 0.0 && x != 1.0 && y > 0.0) 
        {
            wprintf( L"%S; log_%g( %g ) = %g\n", "로그", x, y, log(y)/log(x));
        }
    }

    return 0;
}

/*
Execute & Output:
Prompt> hello_d 1.2 5.4
0: hello_d
1: 1.2
2: 5.4
  합: 1.2 + 5.4 = 6.6
  차: 1.2 - 5.4 = -4.2
  곱: 1.2 * 5.4 = 6.48
  몫: 1.2 / 5.4 = 0.222222
멱승; 1.2**5.4 = 2.67657
로그; log_1.2( 5.4 ) = 9.24959
*/

// Filename: testSwap.cpp
//
//       Test swap functions of C++98 and C++11 specifications.
//
// Compile: cl /EHsc testSwap.cpp
// Compile: g++ -std=c++11 -o testSwap testSwap.cpp
// Compile: g++ -std=c++0x -o testSwap testSwap.cpp
//
// See for detail: http://www.cplusplus.com/reference/algorithm/swap/

#include <iostream>        // std::cout
// #include <algorithm>    // std::swap since C++98
#include <utility>         // std::swap and swap since C++0x
#include <vector>          // std::vector
#include <string>          // std::string

template <typename T>
void printVector(std::vector<T> v)
{
  std::cout << '[';
  for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << " ]\n";
}

int main () {

  int x = 10, y = 20;                      // x:10 y:20
  std::swap(x, y);                         // x:20 y:10

  std::vector<int> foo (4,x), bar (6,y);   // foo:4x20 bar:6x10
  // std::swap(foo, bar);                  // foo:6x10 bar:4x20 since C++98
  swap(foo, bar);                          // foo:6x10 bar:4x20 since C++0x

  std::cout << "foo contains:";
  for (std::vector<int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';
  std::cout << '\n';

  std::string s1 = "Hello,";
  std::string s2 = "world!";
 
  std::cout << s1 << ' ' << s2 << std::endl;
  std::cout << '\n';

  std::cout << "Swapping two strings..." << std::endl;
  s1.swap(s2);
   
  std::cout << s1 << ' ' << s2 << std::endl;
  std::cout << '\n';
 
  std::vector<int> v1(10, 7);
  std::vector<int> v2(5, -1);
  std::cout << "v1 = [";
  for (std::vector<int>::iterator it = v1.begin(); it != v1.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << " ]\n";
  std::cout << "v2 = [";
  for (std::vector<int>::iterator it = v2.begin(); it != v2.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << " ]\n";
  std::cout << '\n';
 
  std::cout << "Swapping two vectors..." << std::endl;
  v1.swap(v2);

  std::cout << "v1 =";
  printVector(v1);
  std::cout << "v2 = ";
  printVector(v2);

  return 0;
}

/*
Output:
foo contains: 10 10 10 10 10 10

Hello, world!

Swapping two strings...
world! Hello,

v1 = [ 7 7 7 7 7 7 7 7 7 7 ]
v2 = [ -1 -1 -1 -1 -1 ]

Swapping two vectors...
v1 =[ -1 -1 -1 -1 -1 ]
v2 = [ 7 7 7 7 7 7 7 7 7 7 ]
*/