Changeset d3849c7


Ignore:
Timestamp:
03/30/15 13:49:08 (6 years ago)
Author:
Richard Sanger <rsangerarj@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
773a2a3
Parents:
c723e9e
Message:

Remove lots of debug prints

Location:
lib
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lib/libtrace_parallel.h

    r7c95027 rd3849c7  
    849849/** Check if a dedicated hasher thread is being used.
    850850 *
     851 * @param[in] libtrace The parallel input trace
    851852 * @return True if the trace has dedicated hasher thread otherwise false.
    852853 *
     
    857858/** Checks if a trace is using a reporter
    858859 *
    859  * @param[in] The parallel input trace
     860 * @param[in] libtrace The parallel input trace
    860861 * @return True if the trace is using a reporter otherwise false
    861862 */
  • lib/trace.c

    rac65c9f rd3849c7  
    824824                if (packet->trace && packet->trace->format->fin_packet) {
    825825                        packet->trace->format->fin_packet(packet);
    826                         //gettimeofday(&tv, NULL);
    827                         //printf ("%d.%06d DESTROYED #%"PRIu64"\n", tv.tv_sec, tv.tv_usec, trace_packet_get(packet));
    828826                }
    829827
     
    13911389                /* Make sure not one bet us to this */
    13921390                if (filter->flag) {
    1393                         printf("Someone bet us to compile the filter\n");
    13941391                        assert (pthread_mutex_unlock(&mutex) == 0);
    13951392                        return 1;
     
    14981495                ASSERT_RET(pthread_mutex_lock(&mutex), == 0);
    14991496                /* Again double check here like the bpf filter */
    1500                 if(filter->jitfilter)
    1501                         printf("Someone bet us to compile the JIT thingy\n");
    1502                 else
     1497                if(!filter->jitfilter)
    15031498                /* Looking at compile_program source this appears to be thread safe
    15041499                 * however if this gets called twice we will leak this memory :(
  • lib/trace_parallel.c

    rc723e9e rd3849c7  
    461461        /* If a hasher thread is running, empty input queues so we don't lose data */
    462462        if (trace_has_dedicated_hasher(trace)) {
    463                 fprintf(stderr, "Trace is using a hasher thread emptying queues\n");
    464463                // The hasher has stopped by this point, so the queue shouldn't be filling
    465464                while(!libtrace_ringbuffer_is_empty(&t->rbuffer) || t->format_data) {
     
    482481                                        assert(packet->error <= 0);
    483482                                }
    484                                 fprintf(stderr, "PREAD_FAILED %d\n", ret);
    485483                                libtrace_ocache_free(&trace->packet_freelist, (void **) &packet, 1, 1);
    486484                                return -1;
     
    522520                pthread_exit(NULL);
    523521        }
    524         //printf("Yay Started perpkt thread #%d\n", (int) get_thread_table_num(trace));
    525522        ASSERT_RET(pthread_mutex_unlock(&trace->libtrace_lock), == 0);
    526523
     
    557554                                        continue;
    558555                                case MESSAGE_DO_STOP: // This is internal
    559                                         fprintf(stderr, "DO_STOP stop!!\n");
    560556                                        goto eof;
    561557                        }
     
    675671                pthread_exit(NULL);
    676672        }
    677 
    678         printf("Hasher Thread started\n");
    679673        ASSERT_RET(pthread_mutex_unlock(&trace->libtrace_lock), == 0);
    680674
     
    755749        for (i = 0; i < trace->perpkt_thread_count; i++) {
    756750                libtrace_packet_t * bcast;
    757                 fprintf(stderr, "Broadcasting error/EOF now the trace is over\n");
    758751                if (i == trace->perpkt_thread_count - 1) {
    759752                        bcast = packet;
     
    766759                        // Unlock early otherwise we could deadlock
    767760                        libtrace_ringbuffer_write(&trace->perpkt_threads[i].rbuffer, bcast);
    768                 } else {
    769                         fprintf(stderr, "SKIPPING THREAD !!!%d!!!/n", (int) i);
    770761                }
    771762                ASSERT_RET(pthread_mutex_unlock(&trace->libtrace_lock), == 0);
     
    846837        /* We store the last error message here */
    847838        if (t->format_data) {
    848                 fprintf(stderr, "Hit me, ohh yeah got error %d\n",
    849                         ((libtrace_packet_t *)t->format_data)->error);
    850839                return ((libtrace_packet_t *)t->format_data)->error;
    851840        }
     
    857846
    858847        if (packets[0]->error <= 0 && packets[0]->error != READ_TICK) {
    859                 fprintf(stderr, "Hit me, ohh yeah returning error %d\n", packets[0]->error);
    860848                return packets[0]->error;
    861849        }
     
    877865                                assert(t->format_data == NULL);
    878866                                t->format_data = packets[i];
    879                                 fprintf(stderr, "Hit me, ohh yeah set error %d\n",
    880                                         ((libtrace_packet_t *)t->format_data)->error);
    881867                        }
    882868                        break;
     
    999985        libtrace_thread_t *t = &trace->reporter_thread;
    1000986
    1001         fprintf(stderr, "Reporter thread starting\n");
    1002 
    1003987        /* Wait until all threads are started */
    1004988        ASSERT_RET(pthread_mutex_lock(&trace->libtrace_lock), == 0);
     
    10601044        uint64_t next_release;
    10611045        libtrace_thread_t *t = &trace->keepalive_thread;
    1062 
    1063         fprintf(stderr, "keepalive thread is starting\n");
    10641046
    10651047        /* Wait until all threads are started */
     
    11441126                FD_SET(mesg_fd, &rfds);
    11451127                // We need to wait
    1146 
    1147                 //printf("WAITING for %d.%d next=%"PRIu64" curr=%"PRIu64" seconds packettime %f\n", delay_tv.tv_sec, delay_tv.tv_usec, next_release, curr_usec, trace_get_seconds(packet));
    11481128                ret = select(mesg_fd+1, &rfds, NULL, NULL, &delay_tv);
    11491129                if (ret == 0) {
     
    11521132                        return READ_MESSAGE;
    11531133                } else {
    1154                         fprintf(stderr, "I thnik we broke select\n");
     1134                        assert(!"trace_delay_packet: Unexpected return from select");
    11551135                }
    11561136        }
     
    13201300            trace_supports_parallel(libtrace) &&
    13211301            !trace_has_dedicated_hasher(libtrace)) {
    1322                 fprintf(stderr, "Restarting trace pstart_input()\n");
    13231302                err = libtrace->format->pstart_input(libtrace);
    13241303        } else {
    13251304                if (libtrace->format->start_input) {
    1326                         fprintf(stderr, "Restarting trace start_input()\n");
    13271305                        err = libtrace->format->start_input(libtrace);
    13281306                }
     
    15221500                env = getenv(env_name);
    15231501                if (env) {
    1524                         printf("Got %s=%s", env_name, env);
    15251502                        trace_set_configuration(libtrace, env);
    15261503                }
     
    15311508        env = getenv(env_name);
    15321509        if (env) {
    1533                 printf("Got %s=%s", env_name, env);
    15341510                trace_set_configuration(libtrace, env);
    15351511        }
     
    15871563        if (trace_supports_parallel(libtrace) &&
    15881564            !trace_has_dedicated_hasher(libtrace)) {
    1589                 printf("Using the parallel trace format\n");
    15901565                ret = libtrace->format->pstart_input(libtrace);
    15911566                libtrace->pread = trace_pread_packet_wrapper;
    15921567        } else {
    1593                 printf("Using single threaded interface\n");
    15941568                if (libtrace->format->start_input) {
    15951569                        ret = libtrace->format->start_input(libtrace);
     
    17661740        ASSERT_RET(pthread_mutex_lock(&libtrace->libtrace_lock), == 0);
    17671741        if (!libtrace->started || libtrace->state != STATE_RUNNING) {
    1768                 fprintf(stderr, "pause failed started=%d state=%s (%d)\n", libtrace->started, get_trace_state_name(libtrace->state), libtrace->state);
    17691742                trace_set_err(libtrace,TRACE_ERR_BAD_STATE, "You must call trace_start() before calling trace_ppause()");
    17701743                ASSERT_RET(pthread_mutex_unlock(&libtrace->libtrace_lock), == 0);
     
    18601833        } else {
    18611834                int err;
    1862                 fprintf(stderr, "Trace is not parallel so we are doing a normal pause %s\n", libtrace->uridata);
    18631835                err = trace_pause(libtrace);
    18641836                // We should handle this a bit better
     
    19701942         * user controlled */
    19711943        for (i=0; i< libtrace->perpkt_thread_count; i++) {
    1972                 //printf("Waiting to join with perpkt #%d\n", i);
    19731944                ASSERT_RET(pthread_join(libtrace->perpkt_threads[i].tid, NULL), == 0);
    1974                 //printf("Joined with perpkt #%d\n", i);
    19751945                // So we must do our best effort to empty the queue - so
    19761946                // the producer (or any other threads) don't block.
     
    23322302                uc->debug_state = config_bool_parse(value, nvalue);
    23332303        } else {
    2334                 fprintf(stderr, "No matching value %s(=%s)\n", key, value);
     2304                fprintf(stderr, "No matching option %s(=%s), ignoring\n", key, value);
    23352305        }
    23362306}
     
    23532323                        config_string(&trace->config, key, sizeof(key), value, sizeof(value));
    23542324                } else {
    2355                         fprintf(stderr, "Error parsing %s\n", pch);
     2325                        fprintf(stderr, "Error parsing option %s\n", pch);
    23562326                }
    23572327                pch = strtok (NULL," ,.-");
Note: See TracChangeset for help on using the changeset viewer.