Exemple #1
0
int main(int argc, char **argv)
{
    struct option long_options[] = {
        // These options don't set a flag
        {"help",                      no_argument,       NULL, 'h'},
        {"alternate",                 no_argument,       NULL, 'A'},
        {"effective",                 required_argument, NULL, 'f'},
        {"duration",                  required_argument, NULL, 'd'},
        {"initial-size",              required_argument, NULL, 'i'},
        {"num-threads",               required_argument, NULL, 't'},
        {"range",                     required_argument, NULL, 'r'},
        {"seed",                      required_argument, NULL, 'S'},
        {"update-rate",               required_argument, NULL, 'u'},
        {"move-rate",                 required_argument, NULL, 'a'},
        {"snapshot-rate",             required_argument, NULL, 's'},
        {"lock-alg",                  required_argument, NULL, 'x'},
        {NULL, 0, NULL, 0}
    };

    ht_intset_t *set;
    int i, c, size;
    val_t last = 0;
    val_t val = 0;
    unsigned long reads, effreads, updates, effupds, moves, moved, snapshots,
             snapshoted, aborts, aborts_locked_read, aborts_locked_write,
             aborts_validate_read, aborts_validate_write, aborts_validate_commit,
             aborts_invalid_memory, max_retries;
    thread_data_t *data;
    pthread_t *threads;
    pthread_attr_t attr;
    barrier_t barrier;
    struct timeval start, end;
    struct timespec timeout;
    int duration = DEFAULT_DURATION;
    int initial = DEFAULT_INITIAL;
    int nb_threads = DEFAULT_NB_THREADS;
    long range = DEFAULT_RANGE;
    int seed = DEFAULT_SEED;
    int update = DEFAULT_UPDATE;
    int load_factor = DEFAULT_LOAD;
    int move = DEFAULT_MOVE;
    int snapshot = DEFAULT_SNAPSHOT;
    int unit_tx = DEFAULT_ELASTICITY;
    int alternate = DEFAULT_ALTERNATE;
    int effective = DEFAULT_EFFECTIVE;
    sigset_t block_set;

    while(1) {
        i = 0;
        c = getopt_long(argc, argv, "hAf:d:i:t:r:S:u:a:s:l:x:", long_options, &i);

        if(c == -1)
            break;

        if(c == 0 && long_options[i].flag == 0)
            c = long_options[i].val;

        switch(c) {
        case 0:
            /* Flag is automatically set */
            break;
        case 'h':
            printf("intset -- STM stress test "
                   "(linked list)\n"
                   "\n"
                   "Usage:\n"
                   "  intset [options...]\n"
                   "\n"
                   "Options:\n"
                   "  -h, --help\n"
                   "        Print this message\n"
                   "  -A, --Alternate\n"
                   "        Consecutive insert/remove target the same value\n"
                   "  -f, --effective <int>\n"
                   "        update txs must effectively write (0=trial, 1=effective, default=" XSTR(DEFAULT_EFFECTIVE) ")\n"
                   "  -d, --duration <int>\n"
                   "        Test duration in milliseconds (0=infinite, default=" XSTR(DEFAULT_DURATION) ")\n"
                   "  -i, --initial-size <int>\n"
                   "        Number of elements to insert before test (default=" XSTR(DEFAULT_INITIAL) ")\n"
                   "  -t, --thread-num <int>\n"
                   "        Number of threads (default=" XSTR(DEFAULT_NB_THREADS) ")\n"
                   "  -r, --range <int>\n"
                   "        Range of integer values inserted in set (default=" XSTR(DEFAULT_RANGE) ")\n"
                   "  -S, --seed <int>\n"
                   "        RNG seed (0=time-based, default=" XSTR(DEFAULT_SEED) ")\n"
                   "  -u, --update-rate <int>\n"
                   "        Percentage of update transactions (default=" XSTR(DEFAULT_UPDATE) ")\n"
                   "  -a , --move-rate <int>\n"
                   "        Percentage of move transactions (default=" XSTR(DEFAULT_MOVE) ")\n"
                   "  -s , --snapshot-rate <int>\n"
                   "        Percentage of snapshot transactions (default=" XSTR(DEFAULT_SNAPSHOT) ")\n"
                   "  -l , --load-factor <int>\n"
                   "        Ratio of keys over buckets (default=" XSTR(DEFAULT_LOAD) ")\n"
                   "  -x, --unit-tx (default=1)\n"
                   "        Use unit transactions\n"
                   "        0 = non-protected,\n"
                   "        1 = normal transaction,\n"
                   "        2 = read unit-tx,\n"
                   "        3 = read/add unit-tx,\n"
                   "        4 = read/add/rem unit-tx,\n"
                   "        5 = all recursive unit-tx,\n"
                   "        6 = harris lock-free\n"
                  );
            exit(0);
        case 'A':
            alternate = 1;
            break;
        case 'f':
            effective = atoi(optarg);
            break;
        case 'd':
            duration = atoi(optarg);
            break;
        case 'i':
            initial = atoi(optarg);
            break;
        case 't':
            nb_threads = atoi(optarg);
            break;
        case 'r':
            range = atol(optarg);
            break;
        case 'S':
            seed = atoi(optarg);
            break;
        case 'u':
            update = atoi(optarg);
            break;
        case 'a':
            move = atoi(optarg);
            break;
        case 's':
            snapshot = atoi(optarg);
            break;
        case 'l':
            load_factor = atoi(optarg);
            break;
        case 'x':
            unit_tx = atoi(optarg);
            break;
        case '?':
            printf("Use -h or --help for help\n");
            exit(0);
        default:
            exit(1);
        }
    }

    assert(duration >= 0);
    assert(initial >= 0);
    assert(nb_threads > 0);
    assert(range > 0 && range >= initial);
    assert(update >= 0 && update <= 100);
    assert(move >= 0 && move <= update);
    assert(snapshot >= 0 && snapshot <= (100-update));
    assert(load_factor >= 1);

    printf("Set type     : hash table\n");
    printf("Duration     : %d\n", duration);
    printf("Initial size : %d\n", initial);
    printf("Nb threads   : %d\n", nb_threads);
    printf("Value range  : %ld\n", range);
    printf("Seed         : %d\n", seed);
    printf("Update rate  : %d\n", update);
    printf("Load factor  : %d\n", load_factor);
    printf("Move rate    : %d\n", move);
    printf("Update rate  : %d\n", update);
    printf("Lock alg.    : %d\n", unit_tx);
    printf("Alternate    : %d\n", alternate);
    printf("effective    : %d\n", effective);
    printf("Type sizes   : int=%d/long=%d/ptr=%d/word=%d\n",
           (int)sizeof(int),
           (int)sizeof(long),
           (int)sizeof(void *),
           (int)sizeof(uintptr_t));

    timeout.tv_sec = duration / 1000;
    timeout.tv_nsec = (duration % 1000) * 1000000;

    if ((data = (thread_data_t *)malloc(nb_threads * sizeof(thread_data_t))) == NULL) {
        perror("malloc");
        exit(1);
    }
    if ((threads = (pthread_t *)malloc(nb_threads * sizeof(pthread_t))) == NULL) {
        perror("malloc");
        exit(1);
    }

    if (seed == 0)
        srand((int)time(0));
    else
        srand(seed);

    maxhtlength = (unsigned int) initial / load_factor;
    set = ht_new();

    stop = 0;

    /* Populate set */
    printf("Adding %d entries to set\n", initial);
    i = 0;
    //maxhtlength = (int) (initial / load_factor);
    while (i < initial) {
        val = (rand() % range) + 1;
        if (ht_add(set, val, 0)) {
            last = val;
            i++;
        }
    }
    size = ht_size(set);
    printf("Set size     : %d\n", size);
    printf("Bucket amount: %d\n", maxhtlength);
    printf("Load         : %d\n", load_factor);

    /* Access set from all threads */
    barrier_init(&barrier, nb_threads + 1);
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    for (i = 0; i < nb_threads; i++) {
        printf("Creating thread %d\n", i);
        data[i].first = last;
        data[i].range = range;
        data[i].update = update;
        data[i].load_factor = load_factor;
        data[i].move = move;
        data[i].snapshot = snapshot;
        data[i].unit_tx = unit_tx;
        data[i].alternate = alternate;
        data[i].effective = effective;
        data[i].nb_add = 0;
        data[i].nb_added = 0;
        data[i].nb_remove = 0;
        data[i].nb_removed = 0;
        data[i].nb_move = 0;
        data[i].nb_moved = 0;
        data[i].nb_snapshot = 0;
        data[i].nb_snapshoted = 0;
        data[i].nb_contains = 0;
        data[i].nb_found = 0;
        data[i].nb_aborts = 0;
        data[i].nb_aborts_locked_read = 0;
        data[i].nb_aborts_locked_write = 0;
        data[i].nb_aborts_validate_read = 0;
        data[i].nb_aborts_validate_write = 0;
        data[i].nb_aborts_validate_commit = 0;
        data[i].nb_aborts_invalid_memory = 0;
        data[i].max_retries = 0;
        data[i].seed = rand();
        data[i].set = set;
        data[i].barrier = &barrier;
        if (pthread_create(&threads[i], &attr, test, (void *)(&data[i])) != 0) {
            fprintf(stderr, "Error creating thread\n");
            exit(1);
        }
    }
    pthread_attr_destroy(&attr);

    /* Start threads */
    barrier_cross(&barrier);

    printf("STARTING...\n");
    gettimeofday(&start, NULL);
    if (duration > 0) {
        nanosleep(&timeout, NULL);
    } else {
        sigemptyset(&block_set);
        sigsuspend(&block_set);
    }
    AO_store_full(&stop, 1);
    gettimeofday(&end, NULL);
    printf("STOPPING...\n");

    /* Wait for thread completion */
    for (i = 0; i < nb_threads; i++) {
        if (pthread_join(threads[i], NULL) != 0) {
            fprintf(stderr, "Error waiting for thread completion\n");
            exit(1);
        }
    }

    duration = (end.tv_sec * 1000 + end.tv_usec / 1000) - (start.tv_sec * 1000 + start.tv_usec / 1000);
    aborts = 0;
    aborts_locked_read = 0;
    aborts_locked_write = 0;
    aborts_validate_read = 0;
    aborts_validate_write = 0;
    aborts_validate_commit = 0;
    aborts_invalid_memory = 0;
    reads = 0;
    effreads = 0;
    updates = 0;
    effupds = 0;
    moves = 0;
    moved = 0;
    snapshots = 0;
    snapshoted = 0;
    max_retries = 0;
    for (i = 0; i < nb_threads; i++) {
        printf("Thread %d\n", i);
        printf("  #add        : %lu\n", data[i].nb_add);
        printf("    #added    : %lu\n", data[i].nb_added);
        printf("  #remove     : %lu\n", data[i].nb_remove);
        printf("    #removed  : %lu\n", data[i].nb_removed);
        printf("  #contains   : %lu\n", data[i].nb_contains);
        printf("    #found    : %lu\n", data[i].nb_found);
        printf("  #move       : %lu\n", data[i].nb_move);
        printf("  #moved      : %lu\n", data[i].nb_moved);
        printf("  #snapshot   : %lu\n", data[i].nb_snapshot);
        printf("  #snapshoted : %lu\n", data[i].nb_snapshoted);
        printf("  #aborts     : %lu\n", data[i].nb_aborts);
        printf("    #lock-r   : %lu\n", data[i].nb_aborts_locked_read);
        printf("    #lock-w   : %lu\n", data[i].nb_aborts_locked_write);
        printf("    #val-r    : %lu\n", data[i].nb_aborts_validate_read);
        printf("    #val-w    : %lu\n", data[i].nb_aborts_validate_write);
        printf("    #val-c    : %lu\n", data[i].nb_aborts_validate_commit);
        printf("    #inv-mem  : %lu\n", data[i].nb_aborts_invalid_memory);
        printf("  Max retries : %lu\n", data[i].max_retries);
        aborts += data[i].nb_aborts;
        aborts_locked_read += data[i].nb_aborts_locked_read;
        aborts_locked_write += data[i].nb_aborts_locked_write;
        aborts_validate_read += data[i].nb_aborts_validate_read;
        aborts_validate_write += data[i].nb_aborts_validate_write;
        aborts_validate_commit += data[i].nb_aborts_validate_commit;
        aborts_invalid_memory += data[i].nb_aborts_invalid_memory;
        reads += data[i].nb_contains;
        effreads += data[i].nb_contains +
                    (data[i].nb_add - data[i].nb_added) +
                    (data[i].nb_remove - data[i].nb_removed) +
                    (data[i].nb_move - data[i].nb_moved) +
                    data[i].nb_snapshoted;
        updates += (data[i].nb_add + data[i].nb_remove);
        effupds += data[i].nb_removed + data[i].nb_added + data[i].nb_moved;
        moves += data[i].nb_move;
        moved += data[i].nb_moved;
        snapshots += data[i].nb_snapshot;
        snapshoted += data[i].nb_snapshoted;
        size += data[i].nb_added - data[i].nb_removed;
        if (max_retries < data[i].max_retries)
            max_retries = data[i].max_retries;
    }
    printf("Set size      : %d (expected: %d)\n", ht_size(set), size);
    printf("Duration      : %d (ms)\n", duration);
    printf("#txs          : %lu (%f / s)\n", reads + updates + moves + snapshots , (reads + updates + moves + snapshots) * 1000.0 / duration);

    printf("#read txs     : ");
    if (effective) {
        printf("%lu (%f / s)\n", effreads, effreads * 1000.0 / duration);
        printf("  #contains   : %lu (%f / s)\n", reads, reads * 1000.0 / duration);
    } else printf("%lu (%f / s)\n", reads, reads * 1000.0 / duration);

    printf("#eff. upd rate: %f \n", 100.0 * effupds / (effupds + effreads));

    printf("#update txs   : ");
    if (effective) {
        printf("%lu (%f / s)\n", effupds, effupds * 1000.0 / duration);
        printf("  #upd trials : %lu (%f / s)\n", updates, updates * 1000.0 /
               duration);
    } else printf("%lu (%f / s)\n", updates, updates * 1000.0 / duration);

    printf("#move txs     : %lu (%f / s)\n", moves, moves * 1000.0 / duration);
    printf("  #moved      : %lu (%f / s)\n", moved, moved * 1000.0 / duration);
    printf("#snapshot txs : %lu (%f / s)\n", snapshots, snapshots * 1000.0 / duration);
    printf("  #snapshoted : %lu (%f / s)\n", snapshoted, snapshoted * 1000.0 / duration);
    printf("#aborts       : %lu (%f / s)\n", aborts, aborts * 1000.0 / duration);
    printf("  #lock-r     : %lu (%f / s)\n", aborts_locked_read, aborts_locked_read * 1000.0 / duration);
    printf("  #lock-w     : %lu (%f / s)\n", aborts_locked_write, aborts_locked_write * 1000.0 / duration);
    printf("  #val-r      : %lu (%f / s)\n", aborts_validate_read, aborts_validate_read * 1000.0 / duration);
    printf("  #val-w      : %lu (%f / s)\n", aborts_validate_write, aborts_validate_write * 1000.0 / duration);
    printf("  #val-c      : %lu (%f / s)\n", aborts_validate_commit, aborts_validate_commit * 1000.0 / duration);
    printf("  #inv-mem    : %lu (%f / s)\n", aborts_invalid_memory, aborts_invalid_memory * 1000.0 / duration);
    printf("Max retries   : %lu\n", max_retries);

    /* Delete set */
    ht_delete(set);

    free(threads);
    free(data);

    return 0;
}
Exemple #2
0
fapi::ReturnCode fapiDelay(uint64_t i_nanoSeconds, uint64_t i_simCycles)
{
    FAPI_DBG( INFO_MRK "delay %lld nanosec", i_nanoSeconds );
    nanosleep( 0, i_nanoSeconds );
    return fapi::FAPI_RC_SUCCESS;
}
/* like any C program, program's execution begins in main */
int
main(int argc, char* argv[])
{
    int        i;                                /* loop counter          */
    struct timespec delay;			 /* used for wasting time */
    struct requests_queue* requests = NULL;  /* pointer to requests queue */
    struct handler_threads_pool* handler_threads = NULL;
					       /* list of handler threads */

    /* create the requests queue */
    requests = init_requests_queue(&request_mutex, &got_request);
    assert(requests);

    /* create the handler threads list */
    handler_threads =
	init_handler_threads_pool(&request_mutex, &got_request, requests);
    assert(handler_threads);

    /* create the request-handling threads */
    for (i=0; i<NUM_HANDLER_THREADS; i++) {
	add_handler_thread(handler_threads);
    }

    /* run a loop that generates requests */
    for (i=0; i<600; i++) {
	int num_requests; // number of requests waiting to be handled.
	int num_threads;  // number of active handler threads.

	add_request(requests, i);

	num_requests = get_requests_number(requests);
	num_threads = get_handler_threads_number(handler_threads);

	/* if there are too many requests on the queue, spawn new threads */
	/* if there are few requests and too many handler threads, cancel */
	/* a handler thread.          					  */
	if (num_requests > HIGH_REQUESTS_WATERMARK &&
	    num_threads < MAX_NUM_HANDLER_THREADS) {
		printf("main: adding thread: '%d' requests, '%d' threads\n",
		       num_requests, num_threads);
		add_handler_thread(handler_threads);
	}
	if (num_requests < LOW_REQUESTS_WATERMARK &&
		 num_threads > NUM_HANDLER_THREADS) {
	    printf("main: deleting thread: '%d' requests, '%d' threads\n",
		   num_requests, num_threads);
	    delete_handler_thread(handler_threads);
	}

	/* pause execution for a little bit, to allow      */
	/* other threads to run and handle some requests.  */
	if (rand() > 3*(RAND_MAX/4)) { /* this is done about 25% of the time */
	    delay.tv_sec = 0;
	    delay.tv_nsec = 1;
	    nanosleep(&delay, NULL);
	}
    }
    /* modify the flag to tell the handler threads no   */
    /* new requests will be generated.                  */
    {
        int rc;

        rc = pthread_mutex_lock(&request_mutex);
        done_creating_requests = 1;
        rc = pthread_cond_broadcast(&got_request);
        rc = pthread_mutex_unlock(&request_mutex);
    }

    /* cleanup */
    delete_handler_threads_pool(handler_threads);
    delete_requests_queue(requests);
    
    printf("Glory,  we are done.\n");

    return 0;
}
Exemple #4
0
static void delay(struct timespec time)
{
  nanosleep(&time, NULL);
}
Exemple #5
0
int main(int argc, char **argv)
{
    char byte='a';
    struct timespec tp= {0, 100};
    int count=0;
    foo_caddy_t *foo;

    /* Initialize the event library */
    opal_init(&argc, &argv);

    /* setup for threads */
    opal_event_use_threads();

    /* create a new base */
    my_base = orte_event_base_create();

    /* launch a progress thread on that base*/
    pipe(progress_thread_pipe);
    OBJ_CONSTRUCT(&lock, opal_mutex_t);
    OBJ_CONSTRUCT(&cond, opal_condition_t);
    OBJ_CONSTRUCT(&progress_thread, opal_thread_t);
    progress_thread.t_run = progress_engine;
    if (OPAL_SUCCESS != opal_thread_start(&progress_thread)) {
        fprintf(stderr, "Unable to start progress thread\n");
        orte_event_base_finalize(my_base);
        exit(1);
    }

    /* wait a little while - reflects reality in an async system */
    while (count < 100) {
        nanosleep(&tp, NULL);
        count++;
    }
    count=0;

    /* make a dummy event */
    fprintf(stderr, "activating the write_event");
    foo = OBJ_NEW(foo_caddy_t);
    opal_event_set(my_base,
                   &foo->write_event,
                   -1,
                   0,
                   send_handler,
                   foo);
    /* activate it. */
    opal_event_active(&foo->write_event, EV_WRITE, 1);

    /* wait for it to trigger */
    while (!fd_written && count < 1000) {
        if (0 == (count % 100)) {
            fprintf(stderr, "Waiting...\n");
        }
        nanosleep(&tp, NULL);
        count++;
    }

    /* stop the thread */
    OPAL_ACQUIRE_THREAD(&lock, &cond, &active);
    progress_thread_stop = true;
    OPAL_RELEASE_THREAD(&lock, &cond, &active);
    opal_fd_write(progress_thread_pipe[1], 1, &byte);
    opal_thread_join(&progress_thread, NULL);

    /* release the base */
    fprintf(stderr, "Cleaning up\n");
    opal_finalize();
    fprintf(stderr, "Cleanup completed\n");
    return 0;
}
Exemple #6
0
/**
 * Initialisation of the Aptina MT9V117 CMOS sensor
 * (1/6 inch VGA, bottom camera)
 */
void mt9v117_init(void)
{
  struct timespec tim;
  char test[2];

  /* Start PWM 9 (Which probably is the clock of the MT9V117) */
  int pwm9 = open("/sys/class/pwm/pwm_9/run", O_WRONLY | O_CREAT | O_TRUNC, 0666);
  write(pwm9, "0", 1);
  write(pwm9, "1", 1);
  close(pwm9);

  tim.tv_sec = 0;
  tim.tv_nsec = 50000000;
  nanosleep(&tim, NULL);

  /* We open the i2c-0 (because else I needed to convert the strace) */
  int fd_i2c = open("/dev/i2c-0", O_RDWR);
  if (fd_i2c < 0) {
    printf("[MT9V117] Could not open i2c-0\n");
    return;
  }
  if (ioctl(fd_i2c, 0x703, 0x5d) < 0) {
    printf("[MT9V117] Could not change the i2c address to 0x5d\n");
    return;
  }

  /* First reset the device */
  write_reg(fd_i2c, "\x00\x1a\x00\x01", 4);
  write_reg(fd_i2c, "\x00\x1a\x00\x00", 4);
  tim.tv_sec = 0;
  tim.tv_nsec = 100000000;
  nanosleep(&tim, NULL);

  /* Now initialize the device */
  write_reg(fd_i2c, "\x30\x1a\x10\xd0", 4);
  write_reg(fd_i2c, "\x31\xc0\x14\x04", 4);
  write_reg(fd_i2c, "\x3e\xd8\x87\x9c", 4);
  write_reg(fd_i2c, "\x30\x42\x20\xe1", 4);
  write_reg(fd_i2c, "\x30\xd4\x80\x20", 4);
  write_reg(fd_i2c, "\x30\xc0\x00\x26", 4);
  write_reg(fd_i2c, "\x30\x1a\x10\xd4", 4);
  write_reg(fd_i2c, "\xa8\x02\x00\xd3", 4);
  write_reg(fd_i2c, "\xc8\x78\x00\xa0", 4);
  write_reg(fd_i2c, "\xc8\x76\x01\x40", 4);
  write_reg(fd_i2c, "\xbc\x04\x00\xfc", 4);
  write_reg(fd_i2c, "\xbc\x38\x00\x7f", 4);
  write_reg(fd_i2c, "\xbc\x3a\x00\x7f", 4);
  write_reg(fd_i2c, "\xbc\x3c\x00\x7f", 4);
  write_reg(fd_i2c, "\xbc\x04\x00\xf4", 4);

  _write(fd_i2c, "\x09\x82\x00\x01", 4);
  _write(fd_i2c, "\x09\x8a\x70\x00", 4);
  _write(fd_i2c,
         "\xf0\x00\x72\xcf\xff\x00\x3e\xd0\x92\x00\x71\xcf\xff\xff\xf2\x18\xb1\x10\x92\x05\xb1\x11\x92\x04\xb1\x12\x70\xcf\xff\x00\x30\xc0\x90\x00\x7f\xe0\xb1\x13\x70\xcf\xff\xff\xe7\x1c\x88\x36\x09\x0f\x00\xb3",
         50);
  _write(fd_i2c,
         "\xf0\x30\x69\x13\xe1\x80\xd8\x08\x20\xca\x03\x22\x71\xcf\xff\xff\xe5\x68\x91\x35\x22\x0a\x1f\x80\xff\xff\xf2\x18\x29\x05\x00\x3e\x12\x22\x11\x01\x21\x04\x0f\x81\x00\x00\xff\xf0\x21\x8c\xf0\x10\x1a\x22",
         50);
  _write(fd_i2c,
         "\xf0\x60\x10\x44\x12\x20\x11\x02\xf7\x87\x22\x4f\x03\x83\x1a\x20\x10\xc4\xf0\x09\xba\xae\x7b\x50\x1a\x20\x10\x84\x21\x45\x01\xc1\x1a\x22\x10\x44\x70\xcf\xff\x00\x3e\xd0\xb0\x60\xb0\x25\x7e\xe0\x78\xe0",
         50);
  _write(fd_i2c,
         "\xf0\x90\x71\xcf\xff\xff\xf2\x18\x91\x12\x72\xcf\xff\xff\xe7\x1c\x8a\x57\x20\x04\x0f\x80\x00\x00\xff\xf0\xe2\x80\x20\xc5\x01\x61\x20\xc5\x03\x22\xb1\x12\x71\xcf\xff\x00\x3e\xd0\xb1\x04\x7e\xe0\x78\xe0",
         50);
  _write(fd_i2c,
         "\xf0\xc0\x70\xcf\xff\xff\xe7\x1c\x88\x57\x71\xcf\xff\xff\xf2\x18\x91\x13\xea\x84\xb8\xa9\x78\x10\xf0\x03\xb8\x89\xb8\x8c\xb1\x13\x71\xcf\xff\x00\x30\xc0\xb1\x00\x7e\xe0\xc0\xf1\x09\x1e\x03\xc0\xc1\xa1",
         50);
  _write(fd_i2c,
         "\xf0\xf0\x75\x08\x76\x28\x77\x48\xc2\x40\xd8\x20\x71\xcf\x00\x03\x20\x67\xda\x02\x08\xae\x03\xa0\x73\xc9\x0e\x25\x13\xc0\x0b\x5e\x01\x60\xd8\x06\xff\xbc\x0c\xce\x01\x00\xd8\x00\xb8\x9e\x0e\x5a\x03\x20",
         50);
  _write(fd_i2c,
         "\xf1\x20\xd9\x01\xd8\x00\xb8\x9e\x0e\xb6\x03\x20\xd9\x01\x8d\x14\x08\x17\x01\x91\x8d\x16\xe8\x07\x0b\x36\x01\x60\xd8\x07\x0b\x52\x01\x60\xd8\x11\x8d\x14\xe0\x87\xd8\x00\x20\xca\x02\x62\x00\xc9\x03\xe0",
         50);
  _write(fd_i2c,
         "\xf1\x50\xc0\xa1\x78\xe0\xc0\xf1\x08\xb2\x03\xc0\x76\xcf\xff\xff\xe5\x40\x75\xcf\xff\xff\xe5\x68\x95\x17\x96\x40\x77\xcf\xff\xff\xe5\x42\x95\x38\x0a\x0d\x00\x01\x97\x40\x0a\x11\x00\x40\x0b\x0a\x01\x00",
         50);
  _write(fd_i2c,
         "\xf1\x80\x95\x17\xb6\x00\x95\x18\xb7\x00\x76\xcf\xff\xff\xe5\x44\x96\x20\x95\x15\x08\x13\x00\x40\x0e\x1e\x01\x20\xd9\x00\x95\x15\xb6\x00\xff\xa1\x75\xcf\xff\xff\xe7\x1c\x77\xcf\xff\xff\xe5\x46\x97\x40",
         50);
  _write(fd_i2c,
         "\xf1\xb0\x8d\x16\x76\xcf\xff\xff\xe5\x48\x8d\x37\x08\x0d\x00\x81\x96\x40\x09\x15\x00\x80\x0f\xd6\x01\x00\x8d\x16\xb7\x00\x8d\x17\xb6\x00\xff\xb0\xff\xbc\x00\x41\x03\xc0\xc0\xf1\x0d\x9e\x01\x00\xe8\x04",
         50);
  _write(fd_i2c,
         "\xf1\xe0\xff\x88\xf0\x0a\x0d\x6a\x01\x00\x0d\x8e\x01\x00\xe8\x7e\xff\x85\x0d\x72\x01\x00\xff\x8c\xff\xa7\xff\xb2\xd8\x00\x73\xcf\xff\xff\xf2\x40\x23\x15\x00\x01\x81\x41\xe0\x02\x81\x20\x08\xf7\x81\x34",
         50);
  _write(fd_i2c,
         "\xf2\x10\xa1\x40\xd8\x00\xc0\xd1\x7e\xe0\x53\x51\x30\x34\x20\x6f\x6e\x5f\x73\x74\x61\x72\x74\x5f\x73\x74\x72\x65\x61\x6d\x69\x6e\x67\x20\x25\x64\x20\x25\x64\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
         50);
  _write(fd_i2c, "\xf2\x40\xff\xff\xe8\x28\xff\xff\xf0\xe8\xff\xff\xe8\x08\xff\xff\xf1\x54", 18);
  _write(fd_i2c, "\x09\x8e\x00\x00", 4);
  _write(fd_i2c, "\xe0\x00\x05\xd8", 4);
  _write(fd_i2c, "\xe0\x02\x04\x03", 4);
  _write(fd_i2c, "\xe0\x04\x00\x43\x01\x04", 6);

  // Do while succeeded?
  _write(fd_i2c, "\x00\x40\x80\x01", 4);
  while (test[0] != 0xFF || test[1] != 0XF8) {
    tim.tv_sec = 0;
    tim.tv_nsec = 100000000;
    nanosleep(&tim, NULL);
    write(fd_i2c, "\x00\x40", 2);
    read(fd_i2c, test, 2);
    printf("Da: %X%X\n", test[0], test[1]);

    /*if(test[1] == 0XFB) {
      // restart all over??
      mt9v117_init();
      return;
    }*/
  }

  _write(fd_i2c, "\xac\x40\x00\x00\xc3\x50", 6);
  write_reg(fd_i2c, "\xa4\x04\x00\x00", 4);
  //write(fd_i2c, "\x00\x30", 2);
  //read(fd_i2c, "\x04\x00", 2);

  write_reg(fd_i2c, "\x00\x30\x06\x01", 4);
  write_reg(fd_i2c, "\xc8\x00\x00\x0c", 4); //0x0008
  write_reg(fd_i2c, "\xc8\x02\x00\x10", 4);
  write_reg(fd_i2c, "\xc8\x04\x01\xf3", 4); //0x01f5
  write_reg(fd_i2c, "\xc8\x06\x02\x97", 4);
  write_reg(fd_i2c, "\xc8\x08\x01\x11", 4);
  write_reg(fd_i2c, "\xc8\x0a\x00\xa4", 4);
  write_reg(fd_i2c, "\xc8\x0c\x02\xfa", 4);
  write_reg(fd_i2c, "\xc8\x12\x00\x31", 4);
  write_reg(fd_i2c, "\xc8\x14\x01\xe3", 4); //0x00f3
  write_reg(fd_i2c, "\xc8\x28\x00\x03", 4); //0x0007
  write_reg(fd_i2c, "\xc8\x4c\x02\x80", 4);
  write_reg(fd_i2c, "\xc8\x4e\x01\xe0", 4); //240 (0x00f0)
  write_reg(fd_i2c, "\xc8\x50\x03", 3);

  write_reg(fd_i2c, "\xc8\x54\x02\x80", 4); //320 (0x0140)
  write_reg(fd_i2c, "\xc8\x56\x01\xe0", 4); //240 (0x00f0)

  write_reg(fd_i2c, "\xc8\xec\x00\x00", 4);
  write_reg(fd_i2c, "\xc8\xee\x00\x00", 4);
  write_reg(fd_i2c, "\xc8\xf0\x02\x7f", 4); //0x013f
  write_reg(fd_i2c, "\xc8\xf2\x01\xdf", 4); //0x00ef
  write_reg(fd_i2c, "\xc8\xf4\x00\x02", 4);
  write_reg(fd_i2c, "\xc8\xf6\x00\x02", 4);
  write_reg(fd_i2c, "\xc8\xf8\x00\x7f", 4); //0x003f
  write_reg(fd_i2c, "\xc8\xfa\x00\x5f", 4); //0x002f
  write_reg(fd_i2c, "\xc8\x10\x03\x52", 4); //0x0400 (0x045e??)
  write_reg(fd_i2c, "\xc8\x0e\x01\xff", 4); //0x0140 (0x0143??)
  write_reg(fd_i2c, "\xc8\x16\x00\xd4", 4); //0x00b0 (0x00a1??)
  write_reg(fd_i2c, "\xc8\x18\x00\xfe", 4); //0x00d3 (0x00c1??)
  write_reg(fd_i2c, "\xc8\x1a\x00\x01", 4);
  write_reg(fd_i2c, "\xc8\x1c\x00\x02", 4); //0x0001
  write_reg(fd_i2c, "\xc8\x1e\x00\x01", 4);
  write_reg(fd_i2c, "\xc8\x20\x00\x02", 4); //0x0001

  write(fd_i2c, "\xc8\x58", 2);
  read(fd_i2c, test, 2);
  write_reg(fd_i2c, "\xc8\x58\x00\x18", 4);
  write_reg(fd_i2c, "\xdc\x00\x28", 3);

  // Dow while succeeded?
  _write(fd_i2c, "\x00\x40\x80\x02", 4);
  test[0] = 0;
  test[1] = 0;
  while (test[0] != 0xFF || test[1] != 0XF8) {
    tim.tv_sec = 0;
    tim.tv_nsec = 100000000;
    nanosleep(&tim, NULL);
    write(fd_i2c, "\x00\x40", 2);
    read(fd_i2c, test, 2);
    printf("Dt: %X%X\n", test[0], test[1]);
  }

  printf("Done!\n");
  close(fd_i2c);
}
Exemple #7
0
static void *consumer_thread( void *arg )
{
    // Identify the arg
    consumer_sdl self = arg;

    // Get the consumer
    mlt_consumer consumer = &self->parent;

    // Get the properties
    mlt_properties consumer_props = MLT_CONSUMER_PROPERTIES( consumer );

    // Video thread
    pthread_t thread;

    // internal intialization
    int init_audio = 1;
    int init_video = 1;
    mlt_frame frame = NULL;
    mlt_properties properties = NULL;
    int duration = 0;
    int64_t playtime = 0;
    struct timespec tm = { 0, 100000 };
//	int last_position = -1;

    pthread_mutex_lock( &self->refresh_mutex );
    self->refresh_count = 0;
    pthread_mutex_unlock( &self->refresh_mutex );

    // Loop until told not to
    while( self->running )
    {
        // Get a frame from the attached producer
        frame = mlt_consumer_rt_frame( consumer );

        // Ensure that we have a frame
        if ( frame )
        {
            // Get the frame properties
            properties =  MLT_FRAME_PROPERTIES( frame );

            // Get the speed of the frame
            double speed = mlt_properties_get_double( properties, "_speed" );

            // Get refresh request for the current frame
            int refresh = mlt_properties_get_int( consumer_props, "refresh" );

            // Clear refresh
            mlt_events_block( consumer_props, consumer_props );
            mlt_properties_set_int( consumer_props, "refresh", 0 );
            mlt_events_unblock( consumer_props, consumer_props );

            // Play audio
            init_audio = consumer_play_audio( self, frame, init_audio, &duration );

            // Determine the start time now
            if ( self->playing && init_video )
            {
                // Create the video thread
                pthread_create( &thread, NULL, video_thread, self );

                // Video doesn't need to be initialised any more
                init_video = 0;
            }

            // Set playtime for this frame
            mlt_properties_set_int( properties, "playtime", playtime );

            while ( self->running && speed != 0 && mlt_deque_count( self->queue ) > 15 )
                nanosleep( &tm, NULL );

            // Push this frame to the back of the queue
            if ( self->running && speed )
            {
                pthread_mutex_lock( &self->video_mutex );
                if ( self->is_purge && speed == 1.0 )
                {
                    mlt_frame_close( frame );
                    self->is_purge = 0;
                }
                else
                {
                    mlt_deque_push_back( self->queue, frame );
                    pthread_cond_broadcast( &self->video_cond );
                }
                pthread_mutex_unlock( &self->video_mutex );

                // Calculate the next playtime
                playtime += ( duration * 1000 );
            }
            else if ( self->running )
            {
                pthread_mutex_lock( &self->refresh_mutex );
                if ( ( refresh == 0 && self->refresh_count <= 0 ) || self->refresh_count > 1 )
                {
                    consumer_play_video( self, frame );
                    pthread_cond_wait( &self->refresh_cond, &self->refresh_mutex );
                }
                mlt_frame_close( frame );
                self->refresh_count --;
                pthread_mutex_unlock( &self->refresh_mutex );
            }
            else
            {
                mlt_frame_close( frame );
                frame = NULL;
            }

            // Optimisation to reduce latency
            if ( frame && speed == 1.0 )
            {
                // TODO: disabled due to misbehavior on parallel-consumer
//				if ( last_position != -1 && last_position + 1 != mlt_frame_get_position( frame ) )
//					mlt_consumer_purge( consumer );
//				last_position = mlt_frame_get_position( frame );
            }
            else
            {
                mlt_consumer_purge( consumer );
//				last_position = -1;
            }
        }
    }

    // Kill the video thread
    if ( init_video == 0 )
    {
        pthread_mutex_lock( &self->video_mutex );
        pthread_cond_broadcast( &self->video_cond );
        pthread_mutex_unlock( &self->video_mutex );
        pthread_join( thread, NULL );
    }

    while( mlt_deque_count( self->queue ) )
        mlt_frame_close( mlt_deque_pop_back( self->queue ) );

    self->audio_avail = 0;

    return NULL;
}
Exemple #8
0
/**
 Attempt to acquire a lock based on a lockfile, waiting LOCKPOLLINTERVAL
 milliseconds between polls and timing out after timeout seconds,
 thereafter forcibly attempting to obtain the lock if force is non-zero.
 Returns 1 on success, 0 on failure.
 To release the lock the lockfile must be unlinked.
 A unique temporary file named by appending characters to the lockfile name
 is used; any pre-existing file of the same name is subject to deletion.
 */
static int acquire_lock_file(const std::string &lockfile_str, const int timeout, int force)
{
    int fd, timed_out = 0;
    int ret = 0; /* early exit returns failure */
    struct timespec pollint;
    struct timeval start, end;
    double elapsed;
    struct stat statbuf;
    const char * const lockfile = lockfile_str.c_str();

    /*
       (Re)create a unique file and check that it has one only link.
       */
    const std::string linkfile_str = gen_unique_nfs_filename(lockfile);
    const char * const linkfile = linkfile_str.c_str();
    (void)unlink(linkfile);
    /* OK to not use CLO_EXEC here because fishd is single threaded */
    if ((fd = open(linkfile, O_CREAT|O_RDONLY, 0600)) == -1)
    {
        debug(1, L"acquire_lock_file: open: %s", strerror(errno));
        goto done;
    }
    /*
       Don't need to check exit status of close on read-only file descriptors
       */
    close(fd);
    if (stat(linkfile, &statbuf) != 0)
    {
        debug(1, L"acquire_lock_file: stat: %s", strerror(errno));
        goto done;
    }
    if (statbuf.st_nlink != 1)
    {
        debug(1, L"acquire_lock_file: number of hardlinks on unique "
              L"tmpfile is %d instead of 1.", (int)statbuf.st_nlink);
        goto done;
    }
    if (gettimeofday(&start, NULL) != 0)
    {
        debug(1, L"acquire_lock_file: gettimeofday: %s", strerror(errno));
        goto done;
    }
    end = start;
    pollint.tv_sec = 0;
    pollint.tv_nsec = LOCKPOLLINTERVAL * 1000000;
    do
    {
        /*
             Try to create a hard link to the unique file from the
             lockfile.  This will only succeed if the lockfile does not
             already exist.  It is guaranteed to provide race-free
             semantics over NFS which the alternative of calling
             open(O_EXCL|O_CREAT) on the lockfile is not.  The lock
             succeeds if the call to link returns 0 or the link count on
             the unique file increases to 2.
             */
        if (link(linkfile, lockfile) == 0 ||
                (stat(linkfile, &statbuf) == 0 &&
                 statbuf.st_nlink == 2))
        {
            /* Successful lock */
            ret = 1;
            break;
        }
        elapsed = end.tv_sec + end.tv_usec/1000000.0 -
                  (start.tv_sec + start.tv_usec/1000000.0);
        /*
             The check for elapsed < 0 is to deal with the unlikely event
             that after the loop is entered the system time is set forward
             past the loop's end time.  This would otherwise result in a
             (practically) infinite loop.
             */
        if (timed_out || elapsed >= timeout || elapsed < 0)
        {
            if (timed_out == 0 && force)
            {
                /*
                         Timed out and force was specified - attempt to
                         remove stale lock and try a final time
                         */
                (void)unlink(lockfile);
                timed_out = 1;
                continue;
            }
            else
            {
                /*
                         Timed out and final try was unsuccessful or
                         force was not specified
                         */
                debug(1, L"acquire_lock_file: timed out "
                      L"trying to obtain lockfile %s using "
                      L"linkfile %s", lockfile, linkfile);
                break;
            }
        }
        nanosleep(&pollint, NULL);
    }
    while (gettimeofday(&end, NULL) == 0);
done:
    /* The linkfile is not needed once the lockfile has been created */
    (void)unlink(linkfile);
    return ret;
}
Exemple #9
0
int main( int argc, char *argv[]) {
    int c = 0;
    int ret_val = 0;
    int port = 0;
    char network[128];
    char *file = NULL;
    char *iface = NULL;
    char *mcast_addr = NULL;
    int bfd = 0;
    network[0] = '\0';

#ifdef UDPTEST
    int sockfd = 0;
#else
    pgm_error_t* pgm_err = NULL;
    pgm_sock_t *pgm_sock;
    pthread_t nak_thread;
#endif

    while((c = getopt(argc, argv, ":hm:i:p:f:")) != -1) {
        switch (c) {
        case 'm':
            mcast_addr = optarg;
            break;
        case 'i':
            iface = optarg;
            break;
        case 'p':
            port = atoi(optarg);
            break;
        case 'h':
        case '?':
            print_usage();
            break;
        default:
            print_usage();
            break;
        }
    }

    if(optind != argc-1) {
        PRINT_ERR("Please provide the path to a file you want to send!");
        ret_val = -1;
        goto ret_error;
    } else {
        file = argv[optind];
    }

    if (iface) {
        char *ifaddr = pftp_inet_iftoa(iface);
        if (strlen(ifaddr) > 0) {
            strncat(network, ifaddr, 128);
            strncat(network, ";", 128);
        }
    }

    if (mcast_addr) {
        strncat(network, mcast_addr, 128);
    } else {
        strncat(network, PFTP_DEFAULT_MCAST_ADDR, 128);
    }

#ifdef UDPTEST
    struct sockaddr_in servaddr;

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = inet_addr(PFTP_DEFAULT_MCAST_ADDR);
    servaddr.sin_port = port ? htons(port) : htons(PFTP_UDP_PORT);
#else

    if (0 != pftp_create(1, network, port, &pgm_sock)) {
        ret_val = -1;
        goto ret_error;
    }

    int pgm_status;

    /* Start NAK receiver thread */
    m_run_receiver = 1;
    pthread_create(&nak_thread, NULL, nak_routine, (void*)pgm_sock);
#endif

    char buf[PGMBUF_SIZE];
    buf[0] = '\0';

    struct stat fstat;
    if (-1 == stat(file, &fstat)) {
        PRINT_ERR("Couldn't stat file: %s", strerror(errno));
        ret_val = -1;
        goto ret_error;
    }

    char *fname = strrchr(file, '/');
    if (!fname) {
        fname = file;
    } else {
        fname = fname+1;
    }

    memset(buf, 0, PGMBUF_SIZE);
    snprintf(buf, PGMBUF_SIZE, CMD_SEND_FILE" %ld %s", fstat.st_size, fname);
    PRINT_DBG("Sending file with command: %s", buf);

    size_t bytes_written;
    int bytes_read;

#ifdef UDPTEST
    bytes_written = sendto(sockfd, buf, strlen(buf)+1, 0, (struct sockaddr*)&servaddr, sizeof(servaddr));
    if (bytes_written != strlen(buf)+1) {
        PRINT_ERR("Couldn't send file transfer command! %s", strerror(errno));
        ret_val = -1;
        goto ret_error;
    }
#else
    pgm_status = pgm_status = pgm_send(pgm_sock, buf, strlen(buf)+1, &bytes_written);
    if (pgm_status != PGM_IO_STATUS_NORMAL) {
        PRINT_ERR("Couldn't send file transfer command!");
        ret_val = -1;
        goto ret_error;
    }
#endif

    bfd = open(file, O_RDONLY);
    if (bfd < 0) {
        PRINT_ERR("Couldn't open file for reading! %s", strerror(errno));
        ret_val = -1;
        goto ret_error;
    }

    int fds = 0;
    fd_set writefds;
    fd_set readfds;

    bytes_read = read(bfd, buf, PGMBUF_SIZE);
    while (bytes_read > 0) {

#ifdef UDPTEST

        bytes_written = sendto(sockfd, buf, bytes_read, 0, (struct sockaddr*)&servaddr, sizeof(servaddr));

#else
        struct timeval tv;
        pgm_status = pgm_send(pgm_sock, buf, bytes_read, &bytes_written);

        //PRINT_DBG("pgm_status: %d", pgm_status);

        switch (pgm_status) {

        case PGM_IO_STATUS_NORMAL :
        {
#endif
            if (bytes_written != bytes_read) {
                PRINT_ERR("Error sending file!");
                ret_val = -1;
                goto ret_error;
            }
            bytes_read = read(bfd, buf, PGMBUF_SIZE);

#ifdef UDPTEST
            struct timespec ts = {0, 35000};
            nanosleep(&ts, NULL);
#else
        } break;
        case PGM_IO_STATUS_TIMER_PENDING:
        {
            socklen_t optlen = sizeof(tv);
            pgm_getsockopt (pgm_sock, IPPROTO_PGM, PGM_TIME_REMAIN, &tv, &optlen);
            if (0 == (tv.tv_sec * 1000) + ((tv.tv_usec + 500) / 1000))
                break;
            goto block;
        }
        case PGM_IO_STATUS_RATE_LIMITED :
        {
            socklen_t optlen = sizeof(tv);
            pgm_getsockopt (pgm_sock, IPPROTO_PGM, PGM_RATE_REMAIN, &tv, &optlen);
            if (0 == (tv.tv_sec * 1000) + ((tv.tv_usec + 500) / 1000))
                break;
            /* No accidental fallthrough! */
        }
        case PGM_IO_STATUS_CONGESTION :
        case PGM_IO_STATUS_WOULD_BLOCK :
block:
        {
            FD_ZERO(&writefds);
            pgm_select_info(pgm_sock, NULL, &writefds, &fds);
            fds = select(fds, NULL, &writefds, NULL, pgm_status == PGM_IO_STATUS_WOULD_BLOCK ? NULL : &tv);
        } break;
        default:
            PRINT_ERR("Send error!");
            ret_val = -1;
            goto ret_error;
            break;
        }
#endif
    }

#ifndef UDPTEST
    pthread_mutex_lock(&m_pftp_mutex);
    m_run_receiver = 0;
    pthread_mutex_unlock(&m_pftp_mutex);
    pthread_join(nak_thread, NULL);
    pthread_mutex_destroy(&m_pftp_mutex);
#endif

    goto ret_good;

ret_error:
    PRINT_DBG("Exit error");
    goto ret;
ret_good:
    PRINT_DBG("Exit good");
ret:
    if (bfd > 0)
        close(bfd);
#ifdef UDPTEST
    if (sockfd > 0)
        close(sockfd);
#else
    if (pgm_sock) {
        pftp_stop(pgm_sock);
    }
#endif
    return ret_val;
}
Exemple #10
0
int
main(int argc, char *argv[])
{
	int ch;
	time_t secs = 0, t;
	char *cp;
	long nsecs = 0;
	struct timespec rqtp;
	int i;

	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	signal(SIGALRM, alarmh);

	while ((ch = getopt(argc, argv, "")) != -1)
		switch(ch) {
		default:
			usage();
		}
	argc -= optind;
	argv += optind;

	if (argc != 1)
		usage();

	cp = *argv;
	while ((*cp != '\0') && (*cp != '.')) {
		if (!isdigit((unsigned char)*cp))
			usage();
		t = (secs * 10) + (*cp++ - '0');
		if (t / 10 != secs)	/* oflow */
			return (EINVAL);
		secs = t;
	}

	/* Handle fractions of a second */
	if (*cp == '.') {
		cp++;
		for (i = 100000000; i > 0; i /= 10) {
			if (*cp == '\0')
				break;
			if (!isdigit((unsigned char)*cp))
				usage();
			nsecs += (*cp++ - '0') * i;
		}

		/*
		 * We parse all the way down to nanoseconds
		 * in the above for loop. Be pedantic about
		 * checking the rest of the argument.
		 */
		while (*cp != '\0') {
			if (!isdigit((unsigned char)*cp++))
				usage();
		}
	}

	rqtp.tv_sec = secs;
	rqtp.tv_nsec = nsecs;

	if ((secs > 0) || (nsecs > 0))
		if (nanosleep(&rqtp, NULL))
			err(1, NULL);
	return (0);
}
void
*os_sound_start_thread(void *_ca)
{
  jcall_t *ca = (jcall_t*)_ca;
  char data_in[512];
#ifdef USE_PCM
  char data_in_dec[1024];
#endif
  int have_more = 0;
  int timestamp = 0;
  int i;
  mblk_t *mp;
  struct timeval pkt_in_time, pkt_out_time, sleeptime;
  struct timespec sleepns;

  printf("rtp reading thread started\n");
  while (ca->enable_audio != -1)
    {
#if !MINIMIZE_COPYING
      do
	{
	  memset(data_in, 0, 160);
	  i = rtp_session_recv_with_ts(ca->rtp_session, data_in, 160, timestamp, &have_more);
	  if (i>0) {

#ifdef USE_PCM
	    if (ca->payload==8) /* A-Law */
	      alaw_dec(data_in, data_in_dec, 160);
	    if (ca->payload==0) /* Mu-Law */
	      mulaw_dec(data_in, data_in_dec, 160);

	    write(fd, data_in_dec, i*2);
#else
	    write(fd, data_in, i);
#endif
	  }
	} while(have_more);
#else /* MINIMIZE_COPYING */


      if ( (mp=rtp_session_recvm_with_ts(ca->rtp_session,timestamp))!=NULL) 
	{
	  int 	len=mp->b_cont->b_wptr-mp->b_cont->b_rptr;
	  
	  gettimeofday(&pkt_in_time, 0);
	  if (ca->enable_audio != -1)
	    {
#ifdef USE_PCM
	      if (ca->payload==8) /* A-Law */
		alaw_dec(mp->b_cont->b_rptr, data_in_dec, len);
	    
	      if (ca->payload==0) /* Mu-Law */
		mulaw_dec(mp->b_cont->b_rptr, data_in_dec, len);

	      write(fd, data_in_dec, len*2);
#else
	      write(fd, mp->b_cont->b_rptr, len);
#endif
	    }
	  if (ca->enable_audio == -1)
	    dbgbpt1();
	  freemsg(mp);
	  gettimeofday(&pkt_out_time, 0);
	  /* compute the time we spent processing the packet */
	  tvsub(&pkt_out_time, &pkt_in_time);
	}
#endif

      sleeptime.tv_usec = 10000; sleeptime.tv_sec = 0;
      tvsub(&sleeptime, &pkt_out_time);
      TIMEVAL_TO_TIMESPEC(&sleeptime, &sleepns);
#if !BLOCKING_MODE
      if (ca->enable_audio != -1)
	nanosleep(&sleepns, 0);
#endif
      timestamp += 160;
    }

  printf("rtp reading thread stopping\n");
  dbgbpt2();
  return NULL;
}
Exemple #12
0
int
main (int argc, char **argv)
{
  UProfContext *context;
  UProfReport *report;
  int i;

  uprof_init (&argc, &argv);

  context = uprof_context_new ("Simple context");


  DBG_PRINTF ("start full timer (rdtsc = %" G_GUINT64_FORMAT ")\n",
              uprof_get_system_counter ());
  UPROF_TIMER_START (context, full_timer);
  for (i = 0; i < 2; i ++)
    {
      struct timespec delay;
      UPROF_COUNTER_INC (context, loop0_counter);

      DBG_PRINTF ("start simple timer (rdtsc = %" G_GUINT64_FORMAT ")\n",
                  uprof_get_system_counter ());
      UPROF_TIMER_START (context, loop0_timer);
      DBG_PRINTF ("  <delay: 1/2 sec>\n");
      delay.tv_sec = 0;
      delay.tv_nsec = 1000000000/2;
      nanosleep (&delay, NULL);

      UPROF_TIMER_START (context, loop0_sub_timer);
      DBG_PRINTF ("    <timing sub delay: 1/4 sec>\n");
      delay.tv_sec = 0;
      delay.tv_nsec = 1000000000/4;
      nanosleep (&delay, NULL);
      UPROF_TIMER_STOP (context, loop0_sub_timer);

      UPROF_TIMER_STOP (context, loop0_timer);
      DBG_PRINTF ("stop simple timer (rdtsc = %" G_GUINT64_FORMAT ")\n",
                  uprof_get_system_counter ());
    }

  for (i = 0; i < 4; i ++)
    {
      struct timespec delay;
      UPROF_COUNTER_INC (context, loop1_counter);

      DBG_PRINTF ("start simple timer (rdtsc = %" G_GUINT64_FORMAT ")\n",
                  uprof_get_system_counter ());
      UPROF_TIMER_START (context, loop1_timer);
      DBG_PRINTF ("  <delay: 1/4 sec>\n");
      delay.tv_sec = 0;
      delay.tv_nsec = 1000000000/4;
      nanosleep (&delay, NULL);

      UPROF_TIMER_START (context, loop1_sub_timer);
      DBG_PRINTF ("    <timing sub delay: 1/2 sec>\n");
      delay.tv_sec = 0;
      delay.tv_nsec = 1000000000/2;
      nanosleep (&delay, NULL);
      UPROF_TIMER_STOP (context, loop1_sub_timer);

      UPROF_TIMER_STOP (context, loop1_timer);
      DBG_PRINTF ("stop simple timer (rdtsc = %" G_GUINT64_FORMAT ")\n",
                  uprof_get_system_counter ());
    }

  DBG_PRINTF ("stop full timer (rdtsc = %" G_GUINT64_FORMAT ")\n",
              uprof_get_system_counter ());
  UPROF_TIMER_STOP (context, full_timer);

  report = uprof_report_new ("Simple report");
  uprof_report_add_statistic (report,
                              "Special thingy",
                              "This is a particularly interesting thingy");
  uprof_report_add_statistic_attribute (report,
                                        "Special thingy",
                                        "Thingy A value",
                                        "Thingy A\nvalue",
                                        "The real A value of thingys",
                                        UPROF_ATTRIBUTE_TYPE_WORD,
                                        a_values_cb, NULL);
  uprof_report_add_statistic_attribute (report,
                                        "Special thingy",
                                        "Thingy B value",
                                        "Thingy B\nvalue",
                                        "The real B value of thingys",
                                        UPROF_ATTRIBUTE_TYPE_WORD,
                                        b_values_cb, NULL);

  uprof_report_add_statistic (report,
                              "Special dobble",
                              "This is a particularly interesting dobble");
  uprof_report_add_statistic_attribute (report,
                                        "Special dobble",
                                        "Dobble value",
                                        "Dobble\nvalue",
                                        "The real value of dobbles",
                                        UPROF_ATTRIBUTE_TYPE_FLOAT,
                                        dobbles_cb, NULL);

  uprof_report_add_timers_attribute (report,
                                     "Time in seconds",
                                     "Time in\nseconds",
                                     "The time elapsed in seconds",
                                     UPROF_ATTRIBUTE_TYPE_INT,
                                     seconds_column_cb, NULL);
  uprof_report_add_counters_attribute (report,
                                       "Double count",
                                       "Double\ncount",
                                       "The count doubled",
                                       UPROF_ATTRIBUTE_TYPE_INT,
                                       double_count_cb, NULL);
  uprof_report_add_counters_attribute (report,
                                       "Tripple count",
                                       "Tripple\ncount",
                                       "The count trippled",
                                       UPROF_ATTRIBUTE_TYPE_INT,
                                       tripple_count_cb, NULL);

  uprof_report_add_context (report, context);
  uprof_report_print (report);
  uprof_report_unref (report);

  uprof_context_unref (context);

  return 0;
}
Exemple #13
0
void ook_transmit(const char *filename, int mod) 
{
	FILE *fd = fopen(filename, "r");
	char cmd;
	int arg;	
	int ret;
	struct timespec ts;

	if (!fd) {
		printf("ERROR: Unable to open data file\n");
		return;
	}

	/* Calculate total tx time for calibration */
	float took = 0;
	struct timeval start, stop;
	gettimeofday(&start, NULL);

	while (!feof(fd)) {
		fscanf(fd, "%c%d\n", &cmd, &arg);
		//printf("%c %d\n", cmd, arg);
		switch (cmd) {
		case 'N':
			if (arg == 0) {
				continue;
			} 
			//printf("Sleep for %ld\n", ts.tv_nsec);
			//for (int X = 0; X < arg/162; X ++) {
        		//	ACCESS(CM_GP0DIV) = (0x5a << 24) + mod  + (X/8)%3 - 1 ;
				// Going for 0.077
			//}
			
			ts.tv_sec = 0;
			ts.tv_nsec = arg - 80000;
			ret = nanosleep(&ts, NULL);	
			if (ret != 0) {
				printf("Warning nanosleep returned != 0: %d\n", ret);
				perror("nanosleep");
				return;
			}
			
			continue;
		case 'S': 
			if (arg) {
				//printf("TX 1\n");
				askHigh();
			} else {
				//printf("TX 0\n");
				askLow();
			}
			continue;
		default:
			printf("ERROR: Invalid command in data file: %c\n", cmd);
			return;
		}
	}
	gettimeofday(&stop, NULL);
	took = (stop.tv_sec - start.tv_sec) * 1e6;
	took += (stop.tv_usec - start.tv_usec);
	took /= 1e6;	
	printf("Transmission took %10.5f\n", took);
	fclose(fd);
	return;
}
Exemple #14
0
int main(int argc, char *argv[])
{
        struct udev *udev;
        static const struct option options[] = {
                { "lock-media", no_argument, NULL, 'l' },
                { "unlock-media", no_argument, NULL, 'u' },
                { "eject-media", no_argument, NULL, 'e' },
                { "debug", no_argument, NULL, 'd' },
                { "help", no_argument, NULL, 'h' },
                {}
        };
        bool eject = false;
        bool lock = false;
        bool unlock = false;
        const char *node = NULL;
        int fd = -1;
        int cnt;
        int rc = 0;

        udev = udev_new();
        if (udev == NULL)
                goto exit;

        log_open();
        udev_set_log_fn(udev, log_fn);

        while (1) {
                int option;

                option = getopt_long(argc, argv, "deluh", options, NULL);
                if (option == -1)
                        break;

                switch (option) {
                case 'l':
                        lock = true;
                        break;
                case 'u':
                        unlock = true;
                        break;
                case 'e':
                        eject = true;
                        break;
                case 'd':
                        debug = true;
                        log_set_max_level(LOG_DEBUG);
                        udev_set_log_priority(udev, LOG_DEBUG);
                        break;
                case 'h':
                        printf("Usage: cdrom_id [options] <device>\n"
                               "  --lock-media    lock the media (to enable eject request events)\n"
                               "  --unlock-media  unlock the media\n"
                               "  --eject-media   eject the media\n"
                               "  --debug         debug to stderr\n"
                               "  --help          print this help text\n\n");
                        goto exit;
                default:
                        rc = 1;
                        goto exit;
                }
        }

        node = argv[optind];
        if (!node) {
                log_error("no device\n");
                fprintf(stderr, "no device\n");
                rc = 1;
                goto exit;
        }

        srand((unsigned int)getpid());
        for (cnt = 20; cnt > 0; cnt--) {
                struct timespec duration;

                fd = open(node, O_RDONLY|O_NONBLOCK|(is_mounted(node) ? 0 : O_EXCL));
                if (fd >= 0 || errno != EBUSY)
                        break;
                duration.tv_sec = 0;
                duration.tv_nsec = (100 * 1000 * 1000) + (rand() % 100 * 1000 * 1000);
                nanosleep(&duration, NULL);
        }
        if (fd < 0) {
                log_debug("unable to open '%s'\n", node);
                fprintf(stderr, "unable to open '%s'\n", node);
                rc = 1;
                goto exit;
        }
        log_debug("probing: '%s'\n", node);

        /* same data as original cdrom_id */
        if (cd_capability_compat(udev, fd) < 0) {
                rc = 1;
                goto exit;
        }

        /* check for media - don't bail if there's no media as we still need to
         * to read profiles */
        cd_media_compat(udev, fd);

        /* check if drive talks MMC */
        if (cd_inquiry(udev, fd) < 0)
                goto work;

        /* read drive and possibly current profile */
        if (cd_profiles(udev, fd) != 0)
                goto work;

        /* at this point we are guaranteed to have media in the drive - find out more about it */

        /* get session/track info */
        cd_media_toc(udev, fd);

        /* get writable media state */
        cd_media_info(udev, fd);

work:
        /* lock the media, so we enable eject button events */
        if (lock && cd_media) {
                log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (lock)\n");
                media_lock(udev, fd, true);
        }

        if (unlock && cd_media) {
                log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (unlock)\n");
                media_lock(udev, fd, false);
        }

        if (eject) {
                log_debug("PREVENT_ALLOW_MEDIUM_REMOVAL (unlock)\n");
                media_lock(udev, fd, false);
                log_debug("START_STOP_UNIT (eject)\n");
                media_eject(udev, fd);
        }

        printf("ID_CDROM=1\n");
        if (cd_cd_rom)
                printf("ID_CDROM_CD=1\n");
        if (cd_cd_r)
                printf("ID_CDROM_CD_R=1\n");
        if (cd_cd_rw)
                printf("ID_CDROM_CD_RW=1\n");
        if (cd_dvd_rom)
                printf("ID_CDROM_DVD=1\n");
        if (cd_dvd_r)
                printf("ID_CDROM_DVD_R=1\n");
        if (cd_dvd_rw)
                printf("ID_CDROM_DVD_RW=1\n");
        if (cd_dvd_ram)
                printf("ID_CDROM_DVD_RAM=1\n");
        if (cd_dvd_plus_r)
                printf("ID_CDROM_DVD_PLUS_R=1\n");
        if (cd_dvd_plus_rw)
                printf("ID_CDROM_DVD_PLUS_RW=1\n");
        if (cd_dvd_plus_r_dl)
                printf("ID_CDROM_DVD_PLUS_R_DL=1\n");
        if (cd_dvd_plus_rw_dl)
                printf("ID_CDROM_DVD_PLUS_RW_DL=1\n");
        if (cd_bd)
                printf("ID_CDROM_BD=1\n");
        if (cd_bd_r)
                printf("ID_CDROM_BD_R=1\n");
        if (cd_bd_re)
                printf("ID_CDROM_BD_RE=1\n");
        if (cd_hddvd)
                printf("ID_CDROM_HDDVD=1\n");
        if (cd_hddvd_r)
                printf("ID_CDROM_HDDVD_R=1\n");
        if (cd_hddvd_rw)
                printf("ID_CDROM_HDDVD_RW=1\n");
        if (cd_mo)
                printf("ID_CDROM_MO=1\n");
        if (cd_mrw)
                printf("ID_CDROM_MRW=1\n");
        if (cd_mrw_w)
                printf("ID_CDROM_MRW_W=1\n");

        if (cd_media)
                printf("ID_CDROM_MEDIA=1\n");
        if (cd_media_mo)
                printf("ID_CDROM_MEDIA_MO=1\n");
        if (cd_media_mrw)
                printf("ID_CDROM_MEDIA_MRW=1\n");
        if (cd_media_mrw_w)
                printf("ID_CDROM_MEDIA_MRW_W=1\n");
        if (cd_media_cd_rom)
                printf("ID_CDROM_MEDIA_CD=1\n");
        if (cd_media_cd_r)
                printf("ID_CDROM_MEDIA_CD_R=1\n");
        if (cd_media_cd_rw)
                printf("ID_CDROM_MEDIA_CD_RW=1\n");
        if (cd_media_dvd_rom)
                printf("ID_CDROM_MEDIA_DVD=1\n");
        if (cd_media_dvd_r)
                printf("ID_CDROM_MEDIA_DVD_R=1\n");
        if (cd_media_dvd_ram)
                printf("ID_CDROM_MEDIA_DVD_RAM=1\n");
        if (cd_media_dvd_rw)
                printf("ID_CDROM_MEDIA_DVD_RW=1\n");
        if (cd_media_dvd_plus_r)
                printf("ID_CDROM_MEDIA_DVD_PLUS_R=1\n");
        if (cd_media_dvd_plus_rw)
                printf("ID_CDROM_MEDIA_DVD_PLUS_RW=1\n");
        if (cd_media_dvd_plus_rw_dl)
                printf("ID_CDROM_MEDIA_DVD_PLUS_RW_DL=1\n");
        if (cd_media_dvd_plus_r_dl)
                printf("ID_CDROM_MEDIA_DVD_PLUS_R_DL=1\n");
        if (cd_media_bd)
                printf("ID_CDROM_MEDIA_BD=1\n");
        if (cd_media_bd_r)
                printf("ID_CDROM_MEDIA_BD_R=1\n");
        if (cd_media_bd_re)
                printf("ID_CDROM_MEDIA_BD_RE=1\n");
        if (cd_media_hddvd)
                printf("ID_CDROM_MEDIA_HDDVD=1\n");
        if (cd_media_hddvd_r)
                printf("ID_CDROM_MEDIA_HDDVD_R=1\n");
        if (cd_media_hddvd_rw)
                printf("ID_CDROM_MEDIA_HDDVD_RW=1\n");

        if (cd_media_state != NULL)
                printf("ID_CDROM_MEDIA_STATE=%s\n", cd_media_state);
        if (cd_media_session_next > 0)
                printf("ID_CDROM_MEDIA_SESSION_NEXT=%d\n", cd_media_session_next);
        if (cd_media_session_count > 0)
                printf("ID_CDROM_MEDIA_SESSION_COUNT=%d\n", cd_media_session_count);
        if (cd_media_session_count > 1 && cd_media_session_last_offset > 0)
                printf("ID_CDROM_MEDIA_SESSION_LAST_OFFSET=%llu\n", cd_media_session_last_offset);
        if (cd_media_track_count > 0)
                printf("ID_CDROM_MEDIA_TRACK_COUNT=%d\n", cd_media_track_count);
        if (cd_media_track_count_audio > 0)
                printf("ID_CDROM_MEDIA_TRACK_COUNT_AUDIO=%d\n", cd_media_track_count_audio);
        if (cd_media_track_count_data > 0)
                printf("ID_CDROM_MEDIA_TRACK_COUNT_DATA=%d\n", cd_media_track_count_data);
exit:
        if (fd >= 0)
                close(fd);
        udev_unref(udev);
        log_close();
        return rc;
}
bool vis::MpdAudioSource::read(pcm_stereo_sample *buffer,
                               const uint32_t buffer_size)
{
    // try to re-open the stream if it has been closed
    if (m_mpd_fifo_fd < 0)
    {
        open_mpd_fifo();
    }

    auto buffer_size_bytes =
        static_cast<size_t>(sizeof(pcm_stereo_sample) * buffer_size);
    size_t bytes_left = buffer_size_bytes;

    if (m_mpd_fifo_fd >= 0)
    {
        auto attempts = 0;
        memset(buffer, 0, buffer_size_bytes);
        while (bytes_left > 0)
        {
            // Read buffer
            int64_t bytes_read = ::read(m_mpd_fifo_fd, buffer, bytes_left);

            // No bytes left
            if (bytes_read == 0)
            {
                VIS_LOG(vis::LogLevel::WARN, "Could not read any bytes");
                return false;
            }
            // Error reading file. Since non-blocking is set, it's possible
            // there's not enough data yet
            if (bytes_read == -1)
            {
                auto error_code = errno;

                // EAGAIN means data is not ready yet
                if (error_code == EAGAIN)
                {

                    // Try up to k_read_attempts before quiting
                    if (attempts > k_read_attempts)
                    {
                        VIS_LOG(vis::LogLevel::WARN,
                                "Could not finish reading "
                                "buffer, bytes read: %d    "
                                "buffer size: ",
                                bytes_read, buffer_size_bytes);

                        // zero out buffer
                        memset(buffer, 0, buffer_size_bytes);
                        ::close(m_mpd_fifo_fd);
                        m_mpd_fifo_fd = -1;
                        return false;
                    }

                    nanosleep(&k_read_attempt_sleep_timespec, nullptr);
                    ++attempts;
                }
                else
                {
                    VIS_LOG(vis::LogLevel::WARN, "Error reading file: %d %s",
                            error_code, strerror(error_code));
                }
            }
            // Bytes were read fine, continue until buffer is full
            else
            {
                bytes_left -= static_cast<size_t>(bytes_read);
            }
        }

        // Success fully read entire buffer
        return true;
    }

    return false;
}
Exemple #16
0
int main(int argc, char *argv[]) 
{
   struct timespec ts,ts1;
   int i,ncpu;
   int idcpu;
   unsigned long freq[8];
   XEvent event;
   char gov[20];
   char drv[20],*ptr,*endptr;
   char prg[LN_PATH];
   ts.tv_sec=0;
   ts.tv_nsec=DELAY;
   prg[0]=0;
   idcpu=0;

   for(i=0;i<MAX_CPU;i++)
     freq[i]=0;
   if(argc >1)
     {
	for (i=1; i<=argc; i++) 
	  {
	     if (!strcmp(argv[i], "-v"))
	       {
		  printf(WMCPUFREQ_VERSION);
		  exit(0);
	       }
	     if (!strcmp(argv[i], "-exe"))
	       {
		  if(strlen(argv[i+1]) < LN_PATH )
		    strcpy(prg,argv[i+1]);
		  break;
	       }
	     if (!strcmp(argv[i], "-cpuid"))
	       {
		 if(strlen(argv[i+1]) < LN_PATH )
		   idcpu=strtol(argv[i+1],&endptr,0);
		 printf("cpuid= %d \n",idcpu);		  
		 break;
	       }
	     printf("only -v, -exe, -cpuid supported \n");
	     exit(0);
	  }
     }

   /* basic checks */
   if ( idcpu < 0 )
     {
       printf("cpuid < 0 \n");
       exit(-1);
     }

   /* get driver name (guess all cpu have the same driver) */
   ptr=cpufreq_get_driver(cpu);
   if(!ptr)
     {
	printf("no driver found \n");
	exit(-1);
     }
   strcpy(drv,ptr);
   cpufreq_put_driver(ptr);


   /* get number of cpu (0=cpu0, 1=cpu1 ...) */
  
   ncpu=-1;

   for(i=0;i<MAX_CPU;i++)
     {
       if( cpufreq_cpu_exists(idcpu+i) ==0)
	 {
	   printf("cpuid %d found\n",idcpu+i);
	   ncpu=i;
	 }
     }

   switch ( ncpu ) {
   case -1:
     printf("no cpuid found \n");
     exit(-1);
   case 0:
     wm_xpm=wmcpufreq_master_xpm_1;
     wm_bits=wmcpufreq_mask_bits_1;
     break;
   case 1:
     wm_xpm=wmcpufreq_master_xpm_2;
     wm_bits=wmcpufreq_mask_bits_2;
     break;
   case 2:
     wm_xpm=wmcpufreq_master_3;
     wm_bits=wmcpufreq_mask_3_bits;
     break;
   case 3:
     wm_xpm=wmcpufreq_master_3;
     wm_bits=wmcpufreq_mask_3_bits;
     break;
   default:
     printf("no yet implemented: cpuid %d \n",ncpu);
     exit(-1);
     break;
   }

   /* guess every cpu has the same limits */
   if(cpufreq_get_hardware_limits(cpu, &f_min, &f_max))
     {
	printf("can't determine hardware limits \n");
	exit(-1);
     }
   openXwindow(argc,argv,
	       wm_xpm,
	       (char*)wm_bits,
	       wmcpufreq_mask_width,
               wmcpufreq_mask_height);   
   while(1) 
     { 
	/* Process any pending X events */
	while(XPending(display)) 
	  {
	     XNextEvent(display, &event);
	     switch(event.type)
	       {
		case Expose:
		  RedrawWindow();
		  break;
		case ButtonPress:
		  if(strlen(prg))
		    execCommand(prg);
		  break;
		case ButtonRelease:
		  break;
	       }
	  }
	RedrawWindow();
	/* get info */
	for(i=0;i<=ncpu;i++)
	  freq[i]=cpufreq_get_freq_kernel(i+idcpu);
	policy=cpufreq_get_policy(cpu);
	strcpy(gov,policy->governor);
	max=policy->max;
	min=policy->min;
	cpufreq_put_policy(policy);
	/* show info */
	show_mhz(freq,ncpu);
	if (ncpu==0)
	  show_driver(drv);
	show_governor(gov);
	/* delay */
	nanosleep(&ts,&ts1);
     }
}
Exemple #17
0
/*
 * timer thread
 *
 * Modes:
 * - clock_nanosleep based
 * - cyclic timer based
 *
 * Clock:
 * - CLOCK_MONOTONIC
 * - CLOCK_REALTIME
 * - CLOCK_MONOTONIC_HR
 * - CLOCK_REALTIME_HR
 *
 */
void *timerthread(void *param)
{
	struct thread_param *par = param;
	struct sched_param schedp;
	sigset_t sigset;
	struct timespec now, next, interval;
	struct thread_stat *stat = par->stats;
	int policy = par->prio ? SCHED_FIFO : SCHED_OTHER;
	int err;
#ifdef __UNSUPPORTED
	struct itimerval itimer;
	struct sigevent sigev;
	timer_t timer;
	struct itimerspec tspec;
#endif
#if (INGO_TRACE + TGLX_TRACE)
	int stopped = 0;
#endif

	interval.tv_sec = par->interval / USEC_PER_SEC;
	interval.tv_nsec = (par->interval % USEC_PER_SEC) * 1000;

#if INGO_TRACE
	system("echo 1 > /proc/sys/kernel/trace_all_cpus");
	system("echo 1 > /proc/sys/kernel/trace_enabled");
	system("echo 1 > /proc/sys/kernel/trace_freerunning");
	system("echo 0 > /proc/sys/kernel/trace_print_at_crash");
	system("echo 1 > /proc/sys/kernel/trace_user_triggered");
	system("echo 0 > /proc/sys/kernel/trace_user_trigger_irq");
	system("echo 0 > /proc/sys/kernel/trace_verbose");
	system("echo 0 > /proc/sys/kernel/preempt_thresh");
	system("echo 0 > /proc/sys/kernel/wakeup_timing");
	system("echo 0 > /proc/sys/kernel/preempt_max_latency");
#endif

	stat->tid = gettid();

	sigemptyset(&sigset);
	sigaddset(&sigset, par->signal);
	sigprocmask(SIG_BLOCK, &sigset, NULL);

#ifdef __UNSUPPORTED
	if (par->mode == MODE_CYCLIC) {
		sigev.sigev_notify = SIGEV_THREAD_ID | SIGEV_SIGNAL;
		sigev.sigev_signo = par->signal;
		sigev.sigev_notify_thread_id = stat->tid;
		timer_create(par->clock, &sigev, &timer);
		tspec.it_interval = interval;
	}
#endif

	memset(&schedp, 0, sizeof(schedp));
	schedp.sched_priority = par->prio;
	err = pthread_setschedparam(pthread_self(), policy, &schedp);
#ifdef __XENO__
	if (err) {
	    fprintf(stderr, "pthread_setschedparam: %s\n"
		    "(modprobe xeno_posix?)\n", strerror(err));
	    test_shutdown = 1;
	    return (void *) 1;
	}
#endif

	/* Get current time */
	next = start;
	next.tv_sec++;

#ifdef __UNSUPPORTED
	if (par->mode == MODE_CYCLIC) {
		if (par->timermode == TIMER_ABSTIME)
			tspec.it_value = next;
		else {
			tspec.it_value.tv_nsec = 0;
			tspec.it_value.tv_sec = 1;
		}
		timer_settime(timer, par->timermode, &tspec, NULL);
	}

	if (par->mode == MODE_SYS_ITIMER) {
		itimer.it_value.tv_sec = 1;
		itimer.it_value.tv_usec = 0;
		itimer.it_interval.tv_sec = interval.tv_sec;
		itimer.it_interval.tv_usec = interval.tv_nsec / 1000;
		setitimer (ITIMER_REAL,  &itimer, NULL);
	}
#endif

	stat->threadstarted++;

#if (INGO_TRACE + TGLX_TRACE)
	gettimeofday(0,(struct timezone *)1);
#endif

	while (!test_shutdown) {

		long diff;
#ifdef __UNSUPPORTED
		int sigs;
#endif

		/* Wait for next period */
		switch (par->mode) {
#ifdef __UNSUPPORTED
		case MODE_CYCLIC:
		case MODE_SYS_ITIMER:
			if (sigwait(&sigset, &sigs) < 0)
				goto out;
			break;
#endif

		case MODE_CLOCK_NANOSLEEP:
			if (par->timermode == TIMER_ABSTIME)
				clock_nanosleep(par->clock, TIMER_ABSTIME, &next, NULL);
			else {
				clock_gettime(par->clock, &now);
				clock_nanosleep(par->clock, TIMER_RELTIME, &interval, NULL);
				next.tv_sec = now.tv_sec + interval.tv_sec;
				next.tv_nsec = now.tv_nsec + interval.tv_nsec;
				tsnorm(&next);
			}
			break;

#ifdef __UNSUPPORTED
		case MODE_SYS_NANOSLEEP:
			clock_gettime(par->clock, &now);
			nanosleep(&interval, NULL);
			next.tv_sec = now.tv_sec + interval.tv_sec;
			next.tv_nsec = now.tv_nsec + interval.tv_nsec;
			tsnorm(&next);
			break;
#endif
		}
		clock_gettime(par->clock, &now);

		diff = calcdiff(now, next);
		if (diff < stat->min)
			stat->min = diff;
		if (diff > stat->max) {
			stat->max = diff;
#if IPIPE_TRACE
			if (stat->traced)
				xntrace_user_freeze(diff, 0);
#endif
		}
		stat->avg += (double) diff;

#if (INGO_TRACE + TGLX_TRACE)
		if (!stopped && (diff > tracelimit)) {
			stopped++;
			gettimeofday(0,0);
			test_shutdown++;
		}
#endif
		stat->act = diff;
		stat->cycles++;

		if (par->bufmsk)
			stat->values[stat->cycles & par->bufmsk] = diff;

		next.tv_sec += interval.tv_sec;
		next.tv_nsec += interval.tv_nsec;
		tsnorm(&next);

		if (par->max_cycles && par->max_cycles == stat->cycles)
			break;
	}

#ifdef __UNSUPPORTED
out:
	if (par->mode == MODE_CYCLIC)
		timer_delete(timer);

	if (par->mode == MODE_SYS_ITIMER) {
		itimer.it_value.tv_sec = 0;
		itimer.it_value.tv_usec = 0;
		itimer.it_interval.tv_sec = 0;
		itimer.it_interval.tv_usec = 0;
		setitimer (ITIMER_REAL,  &itimer, NULL);
	}
#endif

	/* switch to normal */
	schedp.sched_priority = 0;
	pthread_setschedparam(pthread_self(), SCHED_OTHER, &schedp);

	stat->threadstarted = -1;

	return NULL;
}
Exemple #18
0
static int csr(int fd, struct uart_t *u, struct termios *ti)
{
    struct timespec tm = {0, 10000000};	/* 10ms - be generous */
    static int csr_seq = 0;	/* Sequence number of command */
    int  divisor;
    int					err;
    struct CSR_Get_Build_ID			cmd1;
    struct CSR_Get_Build_ID_Event		cce;
    struct CSR_Set_UART_Speed		cmd2;

    /* Try to read the build ID of the CSR chip */
    cmd1.bcc.channel = 0xc2;			/* first+last+channel=BCC */
    cmd1.bcc.type = __htob16(0x0000);		/* type = GET-REQ */
    cmd1.bcc.len = __htob16(5 + 4);			/* ??? */
    cmd1.bcc.seq_num = __htob16(csr_seq);		/* seq num */
    csr_seq++;
    cmd1.bcc.var_id = __htob16(0x2819);		/* var_id = CSR_CMD_BUILD_ID */
    cmd1.bcc.status = __htob16(0x0000);		/* status = STATUS_OK */
    /* CSR BCC payload */
    memset(cmd1.data, 0, sizeof(cmd1.data));

    /* Send command */
    err = hci_exec_cmd1(fd, HCI_C_CSR_COMMAND, &cmd1, sizeof(cmd1),
                        ALL_EVENTS_MASK, HCI_SKIP_STATUS);
    if (err)
        return err;

    do {
#if 0	// it's here in original code
        /* Send command */
        err = hci_exec_cmd(fd, &cmd1, ALL_EVENTS_MASK, HCI_SKIP_STATUS, NULL);
        if (err)
            return err;

#endif
        err = hci_recv_event(fd, &cce, sizeof(cce), 20);
        if (err < 0) {
            return err;
        }
    } while (cce.hci.EventCode != 0xFF);

    /* Display that to user */
    BTINFO("CSR build ID 0x%02X-0x%02X\n", cce.data[12], cce.data[11]);

    /* Now, create the command that will set the UART speed */
    cmd2.bcc.channel = 0xc2;
    cmd2.bcc.type = __htob16(0x0002);	// SET-REQ
    cmd2.bcc.len = __htob16(5 + 4);
    cmd2.bcc.seq_num = __htob16(csr_seq);
    csr_seq++;
    cmd2.bcc.var_id = __htob16(0x6802);	// CONFIG_UART
    cmd2.bcc.status = __htob16(0x0000);	// STATUS_OK

    switch (u->speed) {
    case 9600:
        divisor = 0x0027;
        break;
    /* Various speeds ommited */
    case 57600:
        divisor = 0x00EC;
        break;
    case 115200:
        divisor = 0x01D8;
        break;
    /* For Brainbox Pcmcia cards */
    case 460800:
        divisor = 0x075F;
        break;
    case 921600:
        divisor = 0x0EBF;
        break;
    default:
        /* Safe default */
        divisor = 0x01D8;
        u->speed = 115200;
        break;
    }
    /* No parity, one stop bit -> divisor |= 0x0000; */
    cmd2.speed = __htob16(divisor);
    memset(cmd2.extra, 0, sizeof(cmd2.extra));

    err = hci_exec_cmd1(fd, HCI_C_CSR_COMMAND, &cmd2, sizeof(cmd2),
                        ALL_EVENTS_MASK, HCI_SKIP_STATUS);
    if (err)
        return err;

#if 0	// no wait for response in original code
    do {
        err = hci_recv_event(fd, &cce, sizeof(cce), 20);
        if (err < 0) {
            return err;
        }

    } while (cce.hci.EventCode != 0xFF);
#endif
    nanosleep(&tm, NULL);
    return 0;
}
Exemple #19
0
static void *video_thread( void *arg )
{
    // Identify the arg
    consumer_sdl self = arg;

    // Obtain time of thread start
    struct timeval now;
    int64_t start = 0;
    int64_t elapsed = 0;
    struct timespec tm;
    mlt_frame next = NULL;
    mlt_properties properties = NULL;
    double speed = 0;

    // Get real time flag
    int real_time = mlt_properties_get_int( self->properties, "real_time" );

    // Get the current time
    gettimeofday( &now, NULL );

    // Determine start time
    start = ( int64_t )now.tv_sec * 1000000 + now.tv_usec;

    while ( self->running )
    {
        // Pop the next frame
        pthread_mutex_lock( &self->video_mutex );
        next = mlt_deque_pop_front( self->queue );
        while ( next == NULL && self->running )
        {
            pthread_cond_wait( &self->video_cond, &self->video_mutex );
            next = mlt_deque_pop_front( self->queue );
        }
        pthread_mutex_unlock( &self->video_mutex );

        if ( !self->running || next == NULL ) break;

        // Get the properties
        properties =  MLT_FRAME_PROPERTIES( next );

        // Get the speed of the frame
        speed = mlt_properties_get_double( properties, "_speed" );

        // Get the current time
        gettimeofday( &now, NULL );

        // Get the elapsed time
        elapsed = ( ( int64_t )now.tv_sec * 1000000 + now.tv_usec ) - start;

        // See if we have to delay the display of the current frame
        if ( mlt_properties_get_int( properties, "rendered" ) == 1 && self->running )
        {
            // Obtain the scheduled playout time
            int64_t scheduled = mlt_properties_get_int( properties, "playtime" );

            // Determine the difference between the elapsed time and the scheduled playout time
            int64_t difference = scheduled - elapsed;

            // Smooth playback a bit
            if ( real_time && ( difference > 20000 && speed == 1.0 ) )
            {
                tm.tv_sec = difference / 1000000;
                tm.tv_nsec = ( difference % 1000000 ) * 500;
                nanosleep( &tm, NULL );
            }

            // Show current frame if not too old
            if ( !real_time || ( difference > -10000 || speed != 1.0 || mlt_deque_count( self->queue ) < 2 ) )
                consumer_play_video( self, next );

            // If the queue is empty, recalculate start to allow build up again
            if ( real_time && ( mlt_deque_count( self->queue ) == 0 && speed == 1.0 ) )
            {
                gettimeofday( &now, NULL );
                start = ( ( int64_t )now.tv_sec * 1000000 + now.tv_usec ) - scheduled + 20000;
            }
        }

        // This frame can now be closed
        mlt_frame_close( next );
        next = NULL;
    }

    if ( next != NULL )
        mlt_frame_close( next );

    mlt_consumer_stopped( &self->parent );

    return NULL;
}
Exemple #20
0
static int swave(int fd, struct uart_t *u, struct termios *ti)
{
    struct timespec 			tm = {0, 500000};
    int					err;
    struct Swave_Set_UART_Speed		cmd;
    struct Swave_Event			cce;
    struct Swave_Soft_Reset			cmd1;

    // Silicon Wave set baud rate command
    // see HCI Vendor Specific Interface from Silicon Wave
    // first send a "param access set" command to set the
    // appropriate data fields in RAM. Then send a "HCI Reset
    // Subcommand", e.g. "soft reset" to make the changes effective.

    cmd.subcmd = 0x01;		// param sub command
    cmd.tag = 0x11;			// tag 17 = 0x11 = HCI Transport Params
    cmd.length = 0x03;		// length of the parameter following
    cmd.flow = 0x01;		// HCI Transport flow control enable
    cmd.type = 0x01;		// HCI Transport Type = UART

    switch (u->speed) {
    case 19200:
        cmd.speed = 0x03;
        break;
    case 38400:
        cmd.speed = 0x02;
        break;
    case 57600:
        cmd.speed = 0x01;
        break;
    case 115200:
        cmd.speed = 0x00;
        break;
    default:
        u->speed = 115200;
        cmd.speed = 0x00;
        break;
    }
    /* Send command */
    err = hci_exec_cmd1(fd, HCI_C_SWAVE_COMMAND, &cmd, sizeof(cmd),
                        ALL_EVENTS_MASK, HCI_SKIP_STATUS);
    if (err)
        return err;

    nanosleep(&tm, NULL);

    do {
        err = hci_recv_event(fd, &cce, sizeof(cce), 20);
        if (err < 0) {
            return err;
        }
    } while (cce.hci.EventCode != 0xFF);

    cmd1.subcmd = 0x03;		// param sub command
    err = hci_exec_cmd1(fd, HCI_C_SWAVE_COMMAND, &cmd1, sizeof(cmd1),
                        ALL_EVENTS_MASK, HCI_SKIP_STATUS);
    if (err)
        return err;

    nanosleep(&tm, NULL);

    // now the uart baud rate on the silicon wave module is set and effective.
    // change our own baud rate as well. Then there is a reset event comming in
    // on the *new* baud rate. This is *undocumented*! The packet looks like this:
    // 04 FF 01 0B (which would make that a confirmation of 0x0B = "Param
    // subcommand class". So: change to new baud rate, read with timeout, parse
    // data, error handling. BTW: all param access in Silicon Wave is done this way.
    // Maybe this code would belong in a seperate file, or at least code reuse...

    return 0;
}
Exemple #21
0
int main(int argc, char **argv)
{
    int ok;
    if(argc < 2) {
        printf("Enter latency tolerancy in millisec\n");
        return 0;
    }
    int thres_time = PERIOD_NS + (MILLISEC * atoi(*(argv+1)));
    printf("Latency threshold set to +%d\n", thres_time);
    bool fifo = argc == 2;
    printf("main: getpid()=%d, gettid()=%d\n", getpid(), gettid());
    if (fifo) {
        struct sched_param param;
        param.sched_priority = PRIORITY;
        ok = sched_setscheduler(gettid(), SCHED_FIFO, &param);
        printf("sched_setscheduler = %d\n", ok);
    } else {
        ok = setpriority(PRIO_PROCESS, 0 /* self */, -19);
        printf("setpriority = %d\n", ok);
    }
#ifdef USE_TIMER
    timer_t timerid;
    struct sigevent ev;
#endif
    clockid_t clockid;
    clockid = CLOCK_MONOTONIC;
#ifdef USE_TIMER
    ev.sigev_notify = SIGEV_THREAD;
    ev.sigev_signo = 0;
    ev.sigev_value.sival_int = 0;
    ev.sigev_notify_function = notify_function;
    ev.sigev_notify_attributes = NULL;
    //ev.sigev_notify_thread_id = 0;
    ok = timer_create(clockid, &ev, &timerid);
    //printf("timer_create ok=%d, timerid=%p\n", ok, timerid);
#endif
    ok = clock_gettime(CLOCK_MONOTONIC, &previous);
    //printf("clock_gettime ok=%d\n", ok);
#ifdef USE_TIMER
    int flags = 0;
    struct itimerspec new_;
    struct itimerspec old;
    new_.it_interval.tv_sec = 0;
    new_.it_interval.tv_nsec = PERIOD_NS;
    new_.it_value.tv_sec = 0;
    new_.it_value.tv_nsec = PERIOD_NS;
#endif
    int seconds = (int) (((long long) PERIOD_NS * (long long) MAX_COUNT) / 1000000000LL);
    printf("please wait %d seconds\n", seconds);
#ifdef USE_TIMER
    ok = timer_settime(timerid, flags, &new_, &old);
    //printf("timer_settime ok=%d\n", ok);
    sleep(seconds + 1);
    ok = timer_delete(timerid);
    //printf("\ntimer_delete ok=%d\n", ok);
#else
    struct timespec delay;
    delay.tv_sec = 0;
    delay.tv_nsec = PERIOD_NS;
    for (count = 0; count < MAX_COUNT; ++count) {
        {
            android::ScopedTrace(ATRACE_TAG, "nanosleep");
            nanosleep(&delay, NULL);
        }
        struct timespec ts;
        {
            android::ScopedTrace(ATRACE_TAG, "clock_gettime");
            ok = clock_gettime(CLOCK_MONOTONIC, &ts);
        }
        if (0 == ok) {
            unsigned delta_sec = ts.tv_sec - previous.tv_sec;
            int delta_ns = ts.tv_nsec - previous.tv_nsec;
            if (delta_ns < 0) {
                delta_ns += 1000000000;
                --delta_sec;
            }
            
            if(delta_ns > thres_time) {
                printf("[%d] Iterations passed\n", count);
                printf("delta exceeding at %lu.%09lu\n", delta_sec, delta_ns);
                return -1;
            }

            struct timespec delta_x;
            delta_x.tv_sec = delta_sec;
            delta_x.tv_nsec = delta_ns;
            delta_ts[count] = delta_x;
            previous = ts;
            ATRACE_INT("cycle_us", delta_ns / 1000);
        }
    }
#endif
    printf("expected samples: %d, actual samples: %d\n", MAX_COUNT, count);
    qsort(delta_ts, count, sizeof(struct timespec), compar);
    printf("99.8%% CDF, ideal is all ~%d ns:\n", PERIOD_NS);
    int i;
    for (i = (count * 998) / 1000; i < count; ++i) {
        printf("%lu.%09lu\n", delta_ts[i].tv_sec, delta_ts[i].tv_nsec);
    }
    return EXIT_SUCCESS;
}
Exemple #22
0
void *
thread_read_write (void *arg)
{
  struct thread_info *info = (struct thread_info *) arg;
  int i, ret;
  int id, fd;

  /* for request */
  u_int32_t reqx, reqy;
  unsigned long boffset, nblock;
  struct sockaddr_in *serv_addr;
  struct key_request_packet kreq;

  /* for read */
  u_int32_t resx, resy;
  struct sockaddr_in addr;
  socklen_t addrlen;
  struct key_response_packet kresp;
  int kresperr, krespsuberr, krespkeylen;

  struct timeval start, end, res;
  double time;
  int success;
  unsigned long send_count, read_count;

  id = info->id;

  memset (&info->stats, 0, sizeof (struct horus_stats));
  send_count = read_count = 0;

  fd = socket (PF_INET, SOCK_DGRAM, 0);
  if (fd < 0)
    {
      printf ("thread[%d]: Unable to open socket!: %s\n",
              id, strerror (errno));
      return NULL;
    }

  serv_addr = info->serv_addr;
  boffset = info->boffset;
  nblock = info->nblock;
  memset (&kreq, 0, sizeof (kreq));

  reqx = info->level;
  kreq.x = htonl (reqx);
  strncpy (kreq.filename, info->filename, sizeof (kreq.filename));

  if (benchmark || horus_verbose)
    printf ("thread[%d]: server %s:%d bsize %d boffset %lu nblock %lu\n",
            id, info->server, ntohs (serv_addr->sin_port),
            HORUS_BLOCK_SIZE, boffset, nblock);

  if (spinwait)
    {
      fcntl (fd, F_SETFL, O_NONBLOCK);
      printf ("thread[%d]: spinwait: usleep %d nanosleep %ld "
              "nsend %d nread %d\n",
              id, useconds, nanoseconds, nsend, nread);
    }

  if (benchmark)
    gettimeofday (&start, NULL);

  for (i = 0; i < nblock; i++)
    {
      reqy = boffset + i;
      kreq.y = htonl (reqy);

      success = 0;
      send_count = nsend;
      do {
          ret = sendto (fd, &kreq, sizeof (key_request_packet), 0,
                        (struct sockaddr *) serv_addr,
                        sizeof (struct sockaddr_in));
          send_count--;
          if (ret != sizeof (key_request_packet))
            {
              if (horus_debug)
                printf ("thread[%d]: sendto(): failed: %d "
                        "send_count: %ld\n", id, ret, send_count);
              info->stats.sendfail++;
              continue;
            }
          else
            {
              if (horus_debug)
                printf ("thread[%d]: request %d,%d send_count: %ld\n",
                        id, reqx, reqy, send_count);
            }

          read_count = nread;
          do {
              if (spinwait)
                {
                  if (useconds)
                    usleep (useconds);
                  if (nanoseconds)
                    {
                      struct timespec nanospec;
                      nanospec.tv_sec = 0;
                      nanospec.tv_nsec = nanoseconds;
                      nanosleep (&nanospec, NULL);
                    }
                }

              addrlen = sizeof (struct sockaddr_in);
              ret = recvfrom (fd, &kresp, sizeof (key_response_packet), 0,
                              (struct sockaddr *) &addr, &addrlen);
              read_count--;
              if (ret != sizeof (key_response_packet))
                {
                  if (horus_debug)
                    printf ("thread[%d]: recvfrom(): failed: %d "
                            "read_count: %ld\n", id, ret, read_count);
                  info->stats.recvfail++;
                  continue;
                }
              else
                {
                  if (horus_debug)
                    printf ("thread[%d]: recvfrom(): received %d\n", id, ret);

                  resx = ntohl (kresp.x);
                  resy = ntohl (kresp.y);

                  if (resx == reqx && resy == reqy)
                    success++;
                  else
                    {
                      if (horus_debug)
                        printf ("thread[%d]: mismatch: "
                                "req: %d,%d: resp: %d,%d\n",
                                id, reqx, reqy, resx, resy);
                      info->stats.resmismatch++;
                    }
                }
          } while (! success && read_count > 0);
      } while (! success && send_count > 0);

      info->stats.sendretry += nsend - send_count - 1;
      info->stats.recvretry += nread - read_count - 1;

      if (! success)
        {
          if (horus_verbose)
            printf ("thread[%d]: give up K_%d,%d: resend: %lu reread: %lu\n",
                    id, reqx, reqy, send_count, read_count);
          info->stats.giveup++;
          continue;
        }
      info->stats.success++;

      kresperr = (int) ntohs (kresp.err);
      krespsuberr = (int) ntohs (kresp.suberr);
      krespkeylen = (int) ntohl (kresp.key_len);
      horus_stats_record (&info->stats, kresperr, krespsuberr);

      if (horus_verbose && ! benchmark)
        {
          if (kresperr)
            printf ("thread[%d]: err = %d : %s\n", id,
                    kresperr, horus_strerror (kresperr));
          if (krespsuberr)
            printf ("thread[%d]: suberr = %d : %s\n", id,
                    krespsuberr, strerror (krespsuberr));
          if (! kresperr)
            printf ("thread[%d]: key_%d,%d: key_%d,%d/%d = %s\n", id,
                    reqx, reqy, resx, resy, krespkeylen,
                    print_key (kresp.key, krespkeylen));
        }

      if (simulate && ! kresperr)
        {
          char key[HORUS_MAX_KEY_LEN];
          size_t key_len;
          int simx, simy;
          unsigned long sboffset, snblock;
          u_int32_t *kht_block_size;
          int j;

          assert (reqx == resx && reqy == resy);
          simx = info->leaf_level;
          kht_block_size = info->kht_block_size;

          sboffset = resy * (kht_block_size[resx] / kht_block_size[simx]);
          snblock = kht_block_size[resx];

          if (resx == info->leaf_level)
            {
              info->stats.keycalculated = info->stats.success;
            }
          else
            {
              for (j = 0; j < snblock; j++)
                {
                  simy = sboffset + j;
                  key_len = sizeof (key);
                  horus_block_key (key, &key_len, simx, simy,
                                   kresp.key, krespkeylen, resx, resy,
                                   kht_block_size);
                  info->stats.keycalculated++;
                  if (horus_verbose && ! benchmark)
                    printf ("thread[%d]: simulated: K_%d,%d = %s\n", id,
                            simx, simy, print_key (key, key_len));
                }
            }
        }
    }

  if (benchmark)
    gettimeofday (&end, NULL);

  close (fd);

  if (benchmark)
    {
      timeval_sub (&end, &start, &res);
      time = res.tv_sec + res.tv_usec * 0.000001;
      info->timeval = res;
      printf ("thread[%d]: %llu/%lu keys in %f secs ( %f q/s\n",
              id, info->stats.success, nblock, time, info->stats.success/time);
      if (simulate)
        printf ("thread[%d]: %llu keys calculated in %f secs ( %f q/s\n",
                id, info->stats.keycalculated, time,
                info->stats.keycalculated/time);
    }
  else if (horus_verbose)
    {
      printf ("thread[%d]: %llu/%lu keys processed.\n",
              id, info->stats.success, nblock);
      if (simulate)
        printf ("thread[%d]: %llu keys calculated\n",
                id, info->stats.keycalculated);
    }

  return NULL;
}
/*
 * Helper thread to periodically poll the video sources and enqueue the
 * generated frames directed to the remote party to the channel's queue.
 * Using a separate thread also helps because the encoding can be
 * computationally expensive so we don't want to starve the main thread.
 */
static void *video_thread(void *arg)
{
	struct video_desc *env = arg;
	int count = 0;
	char save_display[128] = "";
	int i; /* integer variable used as iterator */

	/* if sdl_videodriver is set, override the environment. Also,
	 * if it contains 'console' override DISPLAY around the call to SDL_Init
	 * so we use the console as opposed to the x11 version of aalib
	 */
	if (!ast_strlen_zero(env->sdl_videodriver)) { /* override */
		const char *s = getenv("DISPLAY");
		setenv("SDL_VIDEODRIVER", env->sdl_videodriver, 1);
		if (s && !strcasecmp(env->sdl_videodriver, "aalib-console")) {
			ast_copy_string(save_display, s, sizeof(save_display));
			unsetenv("DISPLAY");
		}
	}
	sdl_setup(env);
	if (!ast_strlen_zero(save_display)) {
		setenv("DISPLAY", save_display, 1);
	}

	ast_mutex_init(&env->dec_lock);	/* used to sync decoder and renderer */

	if (grabber_open(&env->out)) {
		ast_log(LOG_WARNING, "cannot open local video source\n");
	}

	if (env->out.device_num) {
		env->out.devices[env->out.device_primary].status_index |= IS_PRIMARY | IS_SECONDARY;
	}

	/* even if no device is connected, we must call video_out_init,
	 * as some of the data structures it initializes are
	 * used in get_video_frames()
	 */
	video_out_init(env);

	/* Writes intial status of the sources. */
	if (env->gui) {
		for (i = 0; i < env->out.device_num; i++) {
			print_message(env->gui->thumb_bd_array[i].board,
				src_msgs[env->out.devices[i].status_index]);
		}
	}

	for (;;) {
		struct timespec t = { 0, 50000000 };	/* XXX 20 times/sec */
		struct ast_frame *p, *f;
		struct ast_channel *chan;
		int fd;
		char *caption = NULL, buf[160];

		/* determine if video format changed */
		if (count++ % 10 == 0) {
			if (env->out.sendvideo && env->out.devices) {
				snprintf(buf, sizeof(buf), "%s %s %dx%d @@ %dfps %dkbps",
				env->out.devices[env->out.device_primary].name, env->codec_name,
				env->enc_in.w, env->enc_in.h,
				env->out.fps, env->out.bitrate / 1000);
			} else {
				sprintf(buf, "hold");
			}
			caption = buf;
		}

		/* manage keypad events */
		/* XXX here we should always check for events,
		* otherwise the drag will not work */ 
		if (env->gui)
			eventhandler(env, caption);

		/* sleep for a while */
		nanosleep(&t, NULL);

	    if (env->in) {
			struct video_dec_desc *v = env->in;

			/*
			 * While there is something to display, call the decoder and free
			 * the buffer, possibly enabling the receiver to store new data.
			 */
			while (v->dec_in_dpy) {
				struct fbuf_t *tmp = v->dec_in_dpy;	/* store current pointer */

				/* decode the frame, but show it only if not frozen */
				if (v->d_callbacks->dec_run(v, tmp) && !env->frame_freeze)
					show_frame(env, WIN_REMOTE);
				tmp->used = 0;	/* mark buffer as free */
				tmp->ebit = 0;
				ast_mutex_lock(&env->dec_lock);
				if (++v->dec_in_dpy == &v->dec_in[N_DEC_IN])	/* advance to next, circular */
					v->dec_in_dpy = &v->dec_in[0];

				if (v->dec_in_cur == NULL)	/* receiver was idle, enable it... */
					v->dec_in_cur = tmp;	/* using the slot just freed */
				else if (v->dec_in_dpy == v->dec_in_cur) /* this was the last slot */
					v->dec_in_dpy = NULL;	/* nothing more to display */
				ast_mutex_unlock(&env->dec_lock);
			}
		}

		if (env->shutdown)
			break;
		f = get_video_frames(env, &p);	/* read and display */
		if (!f)
			continue;
		chan = env->owner;
		if (chan == NULL) {
			/* drop the chain of frames, nobody uses them */
			while (f) {
				struct ast_frame *g = AST_LIST_NEXT(f, frame_list);
				ast_frfree(f);
				f = g;
			}
			continue;
		}
		ast_channel_lock(chan);

		/* AST_LIST_INSERT_TAIL is only good for one frame, cannot use here */
		if (ast_channel_readq(chan).first == NULL) {
			ast_channel_readq(chan).first = f;
		} else {
			ast_channel_readq(chan).last->frame_list.next = f;
		}
		ast_channel_readq(chan).last = p;
		/*
		 * more or less same as ast_queue_frame, but extra
		 * write on the alertpipe to signal frames.
		 */
		if (ast_channel_alertable(chan)) {
			for (p = f; p; p = AST_LIST_NEXT(p, frame_list)) {
				if (ast_channel_alert(chan)) {
					ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d: %s!\n",
						ast_channel_name(chan), f->frametype, f->subclass, strerror(errno));
			}
		}
		ast_channel_unlock(chan);
	}
	/* thread terminating, here could call the uninit */
	/* uninitialize the local and remote video environments */
	env->in = dec_uninit(env->in);
	video_out_uninit(env);

	if (env->gui)
		env->gui = cleanup_sdl(env->gui, env->out.device_num);
	ast_mutex_destroy(&env->dec_lock);
	env->shutdown = 0;
	return NULL;
}

static void copy_geometry(struct fbuf_t *src, struct fbuf_t *dst)
{
	if (dst->w == 0)
		dst->w = src->w;
	if (dst->h == 0)
		dst->h = src->h;
}

/*! initialize the video environment.
 * Apart from the formats (constant) used by sdl and the codec,
 * we use enc_in as the basic geometry.
 */
static void init_env(struct video_desc *env)
{
	struct fbuf_t *c = &(env->out.loc_src_geometry);		/* local source */
	struct fbuf_t *ei = &(env->enc_in);		/* encoder input */
	struct fbuf_t *ld = &(env->loc_dpy);	/* local display */
	struct fbuf_t *rd = &(env->rem_dpy);		/* remote display */
	int i; /* integer working as iterator */

	c->pix_fmt = PIX_FMT_YUV420P;	/* default - camera format */
	ei->pix_fmt = PIX_FMT_YUV420P;	/* encoder input */
	if (ei->w == 0 || ei->h == 0) {
		ei->w = 352;
		ei->h = 288;
	}
	ld->pix_fmt = rd->pix_fmt = PIX_FMT_YUV420P; /* sdl format */
	/* inherit defaults */
	copy_geometry(ei, c);	/* camera inherits from encoder input */
	copy_geometry(ei, rd);	/* remote display inherits from encoder input */
	copy_geometry(rd, ld);	/* local display inherits from remote display */

	/* fix the size of buffers for small windows */
	for (i = 0; i < env->out.device_num; i++) {
		env->src_dpy[i].pix_fmt = PIX_FMT_YUV420P;
		env->src_dpy[i].w = SRC_WIN_W;
		env->src_dpy[i].h = SRC_WIN_H;
	}
	/* now we set the default coordinates for the picture in picture
	frames inside the env_in buffers, those can be changed by dragging the
	picture in picture with left click */
	env->out.pip_x = ei->w - ei->w/3;
	env->out.pip_y = ei->h - ei->h/3;
}

/*!
 * The first call to the video code, called by oss_new() or similar.
 * Here we initialize the various components we use, namely SDL for display,
 * ffmpeg for encoding/decoding, and a local video source.
 * We do our best to progress even if some of the components are not
 * available.
 */
void console_video_start(struct video_desc *env, struct ast_channel *owner)
{
	ast_log(LOG_WARNING, "env %p chan %p\n", env, owner);
	if (env == NULL)	/* video not initialized */
		return;
	env->owner = owner;	/* work even if no owner is specified */
	if (env->vthread)
		return;		/* already initialized, nothing to do */
	init_env(env);
	env->out.enc = map_config_video_format(env->codec_name);

	ast_log(LOG_WARNING, "start video out %s %dx%d\n",
		env->codec_name, env->enc_in.w,  env->enc_in.h);
	/*
	 * Register all codecs supported by the ffmpeg library.
	 * We only need to do it once, but probably doesn't
	 * harm to do it multiple times.
	 */
	avcodec_init();
	avcodec_register_all();
	av_log_set_level(AV_LOG_ERROR);	/* only report errors */

	if (env->out.fps == 0) {
		env->out.fps = 15;
		ast_log(LOG_WARNING, "fps unset, forcing to %d\n", env->out.fps);
	}
	if (env->out.bitrate == 0) {
		env->out.bitrate = 65000;
		ast_log(LOG_WARNING, "bitrate unset, forcing to %d\n", env->out.bitrate);
	}
	/* create the thread as detached so memory is freed on termination */
	ast_pthread_create_detached_background(&env->vthread,
		NULL, video_thread, env);
}
Exemple #24
0
char*l="-\\|/";main(int c,char**v){int i=0,p;struct timespec s;if(c<2||kill(p=atoi(v[1],0)))exit(1);s.tv_sec=0;s.tv_nsec=1<<20;for(;!kill(p,0);){dprintf(1,"%c\b",l[++i&3]);nanosleep(&s,0);};dprintf(1," ");}
Exemple #25
0
static void *xmi_random_thread(void *input) {
	unsigned long int temp_number;
	struct timespec sleep_time = {.tv_sec = (time_t) SLEEP_TIME,.tv_nsec = 0};
	int rv;

#if DEBUG == 2
	fprintf(stdout,"Entering xmi_random_thread\n");
#endif

	//for loop keeps running until killed by xmi_end_random_acquisition
	for (;;) {
		//lock
#if DEBUG == 2
		fprintf(stdout,"Before lock in thread\n");
#endif
		rv=pthread_mutex_lock(&xmi_random_mutex);
#if DEBUG == 2
		fprintf(stdout,"After lock in thread: %i\n",rv);
#endif
		if (xmi_numbers_in_memory < MAX_NUMBERS) {
			rv=pthread_mutex_unlock(&xmi_random_mutex);
/*			//open the random device
			if ((random_devicePtr=fopen(RANDOM_DEVICE,"r")) == NULL) {
				fprintf(stderr,"Could not open " RANDOM_DEVICE " for reading: continuing...\n");
				nanosleep(&sleep_time,NULL);
				continue;
			}*/
#if DEBUG == 2
			fprintf(stdout,"Before fread\n");
#endif
			if (fread(&temp_number,sizeof(unsigned long int),1,random_devicePtr) == 1) {
				rv=pthread_mutex_lock(&xmi_random_mutex);
				xmi_random_numbers[xmi_numbers_in_memory++]=temp_number;
				rv=pthread_mutex_unlock(&xmi_random_mutex);
#if DEBUG == 2
				fprintf(stdout,"Found a new number: %lu\n",temp_number);
#endif
			}
//			fclose(random_devicePtr);
		}
		else {
			rv=pthread_mutex_unlock(&xmi_random_mutex);
		}


#if DEBUG == 2
		fprintf(stdout,"Before nanosleep: %i\n",rv);
#endif
		nanosleep(&sleep_time,NULL);
#if DEBUG == 2
		fprintf(stdout,"After nanosleep\n");
#endif
	}
	//this line should never be reached
	return NULL;
}









int xmi_start_random_acquisition_dev(void) {
#if DEBUG == 2
	fprintf(stdout,"Entering xmi_start_random_acquisition\n");
#endif

	if (xmi_random_active == 1) {
		fprintf(stderr,"Random number acquisition already active\n");
		return 0;
	}
	xmi_numbers_in_memory = 0;
	//allocate memory for the random_numbers
	xmi_random_numbers = (unsigned long int*) malloc(sizeof(unsigned long int)*MAX_NUMBERS);
	if (xmi_random_numbers == NULL) {
		fprintf(stderr,"Could not allocate memory for the random numbers\n");
		return 0;
	}


	//open random device
	if ((random_devicePtr=fopen(RANDOM_DEVICE,"r")) == NULL) {
		fprintf(stderr,"Could not open " RANDOM_DEVICE " for reading\n");
		return 0;
	}


	//initialize mutex
	pthread_mutex_init(&xmi_random_mutex,NULL);


	//start the thread
	if (pthread_create(&xmi_random_pthread_t, NULL, xmi_random_thread,NULL) != 0) {
		fprintf(stderr,"Could not create thread xmi_random_thread\n");
		return 0;
	}
	xmi_random_active = 1;
	return 1;


}
Exemple #26
0
/*
 * open a socket to the specified host and port
 */
int open_socket(const char *host, u_int16 port)
{
   struct hostent *infh;
   struct sockaddr_in sa_in;
   int sh, ret, err = 0;
#define TSLEEP (50*1000) /* 50 milliseconds */
   int loops = (GBL_CONF->connect_timeout * 10e5) / TSLEEP;

   DEBUG_MSG("open_socket -- [%s]:[%d]", host, port);

   /* prepare the structures */
   memset((char*)&sa_in, 0, sizeof(sa_in));
   sa_in.sin_family = AF_INET;
   sa_in.sin_port = htons(port);

#if !defined(OS_WINDOWS)
   struct timespec tm;
   tm.tv_sec = 0;
   tm.tv_nsec = (TSLEEP * 1000);
#endif

   /* resolve the hostname */
   if ( (infh = gethostbyname(host)) != NULL )
      memcpy(&sa_in.sin_addr, infh->h_addr, infh->h_length);
   else {
      if ( inet_aton(host, (struct in_addr *)&sa_in.sin_addr.s_addr) == 0 )
         return -ENOADDRESS;
   }

   /* open the socket */
   if ( (sh = socket(AF_INET, SOCK_STREAM, 0)) < 0)
      return -EFATAL;
 
   /* set nonblocking socket */
   set_blocking(sh, 0);
  
   do {
      /* connect to the server */
      ret = connect(sh, (struct sockaddr *)&sa_in, sizeof(sa_in));
      
      /* connect is in progress... */
      if (ret < 0) {
         err = GET_SOCK_ERRNO();
         if (err == EINPROGRESS || err == EALREADY || err == EWOULDBLOCK || err == EAGAIN) {
            /* sleep a quirk of time... */
            DEBUG_MSG("open_socket: connect() retrying: %d", err);
#if !defined(OS_WINDOWS)
            nanosleep(&tm, NULL);
#else
            usleep(TSLEEP);
#endif
         }
      } else { 
         /* there was an error or the connect was successful */
         break;
      }
   } while(loops--);
 
   /* 
    * we cannot recall get_sock_errno because under windows
    * calling it twice would not return the same result
    */
   err = ret < 0 ? err : 0;
   
   /* reached the timeout */
   if (ret < 0 && (err == EINPROGRESS || err == EALREADY || err == EAGAIN)) {
      DEBUG_MSG("open_socket: connect() timeout: %d", err);
      close_socket(sh);
      return -ETIMEOUT;
   }

   /* error while connecting */
   if (ret < 0 && err != EISCONN) {
      DEBUG_MSG("open_socket: connect() error: %d", err);
      close_socket(sh);
      return -EINVALID;
   }
      
   DEBUG_MSG("open_socket: connect() connected.");
   
   /* reset the state to blocking socket */
   set_blocking(sh, 1);
   
   
   DEBUG_MSG("open_socket: %d", sh);
   
   return sh;
}
int JThread::Start()
{
	int status;

	if (!mutexinit)
	{
		if (!runningmutex.IsInitialized())
		{
			if (runningmutex.Init() < 0)
				return ERR_JTHREAD_CANTINITMUTEX;
		}
		if (!continuemutex.IsInitialized())
		{
			if (continuemutex.Init() < 0)
				return ERR_JTHREAD_CANTINITMUTEX;
		}
		if (!continuemutex2.IsInitialized())
		{
			if (continuemutex2.Init() < 0)
				return ERR_JTHREAD_CANTINITMUTEX;
		}
		mutexinit = true;
	}
	
	runningmutex.Lock();
	if (running)
	{
		runningmutex.Unlock();
		return ERR_JTHREAD_ALREADYRUNNING;
	}
	runningmutex.Unlock();
	
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
	
	continuemutex.Lock();
	status = pthread_create(&threadid,&attr,TheThread,this);	
	pthread_attr_destroy(&attr);
	if (status != 0)
	{
		continuemutex.Unlock();
		return ERR_JTHREAD_CANTSTARTTHREAD;
	}
	
	/* Wait until 'running' is set */
	
	runningmutex.Lock();			
	while (!running)
	{
		runningmutex.Unlock();
		
		struct timespec req,rem;

		req.tv_sec = 0;
		req.tv_nsec = 1000000;
		nanosleep(&req,&rem);

		runningmutex.Lock();
	}
	runningmutex.Unlock();
	
	continuemutex.Unlock();
	
	continuemutex2.Lock();
	continuemutex2.Unlock();
	return 0;
}
Exemple #28
0
void fd_runtime_run(void* arg)
{
	FDRuntime* self = FD_RUNTIME(arg);
	struct timespec interval, remainder;
	interval.tv_sec = 0;
	interval.tv_nsec = 49910000; //~50ms;
	unsigned short int x;
	int errorCode = 0;
	gboolean firstRun = TRUE;
	int captureState = CAPTURE_WAITING;
	//int lastCaptureState = -1;
	gboolean samplingStarted = FALSE;
	TriggerMode lastTriggerMode = (TriggerMode) -1;
	while (!fd_runtime_getdeviceisconnected(self))
	{
		sched_yield();
		nanosleep(&interval, &remainder);
		sched_yield();
	}
	while (captureState != LIBUSB_ERROR_NO_DEVICE && !fd_runtime_getstoprunning(self))
	{
		pthread_mutex_lock(&FD_DEVICE(self->device)->deviceMutex);
		for (x = 0; x < COMMAND_COUNT; x++)	{
			if (self->commandPending[x]) {
				fd_device_sendcommand(FD_DEVICE(self->device), self->commands[x]);
				self->commandPending[x] = FALSE;
			}
		}
		for (x = 0; x < CONTROLINDEX_COUNT; x++) {
			if (self->controlPending[x]) {
				fd_device_sendcontrol(FD_DEVICE(self->device), self->controls[x]);
				self->controlPending[x] = FALSE;
			}
		}
		pthread_mutex_unlock(&FD_DEVICE(self->device)->deviceMutex);
		sched_yield();
		nanosleep(&interval, &remainder);
		if(!self->sampling) {
			samplingStarted = FALSE;
			sched_yield();
			continue; //skip the rest of the loop.
		}
		sched_yield();
		pthread_mutex_lock(&FD_DEVICE(self->device)->deviceMutex);
		//lastCaptureState = captureState;
		if (!firstRun)
			captureState = fd_runtime_getcapturestate(self);
		//if(captureState != lastCaptureState)
			//g_message("Capture state changed to %i", captureState);

		switch(captureState) {
		case CAPTURE_READY:
		case CAPTURE_READY5200:
			// Get data and process it, if we're still sampling
			errorCode = getSamples(self, samplingStarted);
			if(errorCode < 0)
				g_message("Getting sample data failed: %i", errorCode);

			// Check if we're in single trigger mode
			if(self->triggerMode == TRIGGERMODE_SINGLE && samplingStarted)
				fd_runtime_stopsampling(self);

			// Sampling completed, restart it when necessary
			samplingStarted = FALSE;

			// Start next capture if necessary by leaving out the break statement
			if(!self->sampling)
				break;

		case CAPTURE_WAITING:
			if(samplingStarted && lastTriggerMode == self->triggerMode)
				break;
			if (firstRun)
				firstRun = FALSE;
			// Start capturing
			errorCode = fd_device_sendcommand(FD_DEVICE(self->device), self->commands[COMMAND_STARTSAMPLING]);
			if(errorCode < 0) {
				if(errorCode == LIBUSB_ERROR_NO_DEVICE)
					captureState = LIBUSB_ERROR_NO_DEVICE;
				break;
			}
			//g_message("Starting to capture");

			// Enable trigger
			errorCode = fd_device_sendcommand(FD_DEVICE(self->device), self->commands[COMMAND_ENABLETRIGGER]);
			if(errorCode < 0) {
				if(errorCode == LIBUSB_ERROR_NO_DEVICE)
					captureState = LIBUSB_ERROR_NO_DEVICE;
				break;
			}
			//g_message("Enabling trigger");

			if(self->triggerMode == TRIGGERMODE_AUTO) {
				// Force triggering
				errorCode = fd_device_sendcommand(FD_DEVICE(self->device), self->commands[COMMAND_FORCETRIGGER]);
				if(errorCode == LIBUSB_ERROR_NO_DEVICE)
					captureState = LIBUSB_ERROR_NO_DEVICE;
				//g_message("Forcing trigger");
			}
			samplingStarted = TRUE;
			lastTriggerMode = self->triggerMode;
			break;

		case CAPTURE_SAMPLING:
			break;
		default:
			if(captureState < 0)
				g_message("Getting capture state failed: %i", captureState);
			break;
		}
		pthread_mutex_unlock(&FD_DEVICE(self->device)->deviceMutex);
	}
}
Exemple #29
0
static void nsleep(uint64_t n) {
	struct timespec timeout;
	timeout.tv_sec = n/1000000000;
	timeout.tv_nsec = n%1000000000;
	while (nanosleep(&timeout, &timeout) && errno == EINTR);
}
Exemple #30
0
void
iC_quit(int sig)
{
#ifdef	RASPBERRYPI
    sig = (*iC_term)(sig);			/* clear and unexport RASPBERRYPI stuff */
#endif	/* RASPBERRYPI */
    /********************************************************************
     *  The following termination function is an empty function
     *  in the libict.a support library.
     *  	int iCend(void) { return -1; }
     *  It may be implemented in a literal block of an iC source, in
     *  which case that function will be linked in preference.
     *  User implementations of iCend() should return 0, to activate
     *  the debug message "== iCend complete ======".
     *
     *  It can be used to free allocated memory, etc.
     *
     *  If the iCbegin() function contains a fork() call, iCend() may have
     *  a matching wait() call.
     *******************************************************************/
    if ((sig >= QUIT_TERMINAL || sig == SIGINT)
	&& iCend() != -1			/* iC termination function */
    ) {
#if	YYDEBUG
	if (iC_debug & 0100) {
	    fprintf(iC_outFP, "\n== iCend complete ======\n");
	}
#endif	/* YYDEBUG */
    }
#ifdef TCP
    if (iC_sockFN > 0) {
	if (sig < SIGUSR1 || sig == QUIT_TERMINAL || sig == QUIT_DEBUGGER) {	/* but not QUIT_SERVER */
#ifdef LOAD
	    if (C_channel) {
		/* disconnect iClive - follow with '0' for iCserver */
		snprintf(regBuf, REQUEST, "%hu:5,%hu:0", C_channel, C_channel);
		iC_send_msg_to_server(iC_sockFN, regBuf);
#ifdef	WIN32
		Sleep(200);			/* 200 ms in ms */
#else	/* WIN32 */
		nanosleep(&ms200, NULL);
#endif	/* WIN32 */
		if (iC_micro) iC_microPrint("Disconnected", 0);
	    }
#endif /* LOAD */
	    if (iC_Xflag) {			/* stop iCserver if this process started it */
		snprintf(regBuf, REQUEST, "X%s", iC_iccNM);
		iC_send_msg_to_server(iC_sockFN, regBuf);
	    }
	    iC_send_msg_to_server(iC_sockFN, "");	/* 0 length message to disconnect from iCserver */
	}
	close(iC_sockFN);			/* close connection to iCserver */
    }
#endif /* TCP */
    /********************************************************************
     *  Normal quit
     *******************************************************************/
    fflush(iC_outFP);				/* in case dangling debug messages without CR */
    if (iC_outFP != stdout) {
	fclose(iC_outFP);
    }
    if ((iC_debug & DQ) == 0) {
	if (sig == QUIT_TERMINAL) {
	    fprintf(iC_errFP, "\n'%s' stopped from terminal\n", iC_iccNM);
	} else if (sig == QUIT_DEBUGGER) {
	    fprintf(iC_errFP, "\n'%s' stopped by debugger\n", iC_iccNM);
	} else if (sig == QUIT_SERVER) {
	    fprintf(iC_errFP, "\n'%s' disconnected by server\n", iC_iccNM);
	}
    }
    if (sig == SIGINT) {
	fprintf(iC_errFP, "\n'%s' stopped by interrupt from terminal\n", iC_iccNM);
    } else if (sig == SIGSEGV) {
	fprintf(iC_errFP, "\n'%s' stopped by 'Invalid memory reference'\n", iC_iccNM);
    } else if (sig == SIGUSR1) {
	fprintf(iC_errFP, "\n'%s' stopped by 'non-recoverable run-time error'\n", iC_iccNM);
    }
#if defined(TCP) && defined(LOAD)
    if (iC_savFP) {
	fflush(iC_savFP);
	fclose(iC_savFP);
    }
    if (iC_vcdFP) {
	fflush(iC_vcdFP);
	fclose(iC_vcdFP);
    }
#endif /* defined(TCP) && defined(LOAD) */
#ifdef	_MSDOS_
    if (oldhandler && iC_debug & 03000) {
	/* reset the old interrupt handler */
#ifdef	MSC
	_dos_setvect(INTR, oldhandler);
#else	/* MSC */
	setvect(INTR, oldhandler);
#endif	/* MSC */
    }
#else	/* ! _MSDOS_ Linux */
    if (ttyparmFlag) {
	if (tcsetattr(0, TCSAFLUSH, &ttyparms) == -1) exit(-1);
    }
#endif	/* ! _MSDOS_ Linux */
    if (iC_errFP != stderr) {
	fflush(iC_errFP);
	fclose(iC_errFP);
    }
#if defined(TCP) && defined(EFENCE)
    free(rpyBuf);
    free(regBuf);
#ifdef	LOAD
    free(msgBuf);
    free(iC_outBuf);
#endif	/* LOAD */
#endif /* defined(TCP) && defined(EFENCE) */
    exit(sig < QUIT_TERMINAL ? sig : 0);	/* really quit */
} /* iC_quit */