Ignore:
Timestamp:
03/23/15 17:52:17 (7 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:
773d5e2
Parents:
963b13b
Message:

Removes pconfig_input() and replaces trace_config() with trace_set_<option>

  • Removes trace_pconfig completely - only trace_set_hasher is left now in trace_config
  • Rework user configuration so this is no longer modified directly. Now we just apply it directly to a trace.
  • Many minor documentation fixes and additions
File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/trace_parallel.c

    r963b13b r6b98325  
    13731373        if (libtrace->config.burst_size <= 0)
    13741374                libtrace->config.burst_size = 10;
    1375         if (libtrace->config.packet_thread_cache_size <= 0)
    1376                 libtrace->config.packet_thread_cache_size = 20;
    1377         if (libtrace->config.packet_cache_size <= 0)
    1378                 libtrace->config.packet_cache_size = (libtrace->config.hasher_queue_size + 1) * libtrace->perpkt_thread_count;
    1379 
    1380         if (libtrace->config.packet_cache_size <
     1375        if (libtrace->config.thread_cache_size <= 0)
     1376                libtrace->config.thread_cache_size = 20;
     1377        if (libtrace->config.cache_size <= 0)
     1378                libtrace->config.cache_size = (libtrace->config.hasher_queue_size + 1) * libtrace->perpkt_thread_count;
     1379
     1380        if (libtrace->config.cache_size <
    13811381                (libtrace->config.hasher_queue_size + 1) * libtrace->perpkt_thread_count)
    13821382                fprintf(stderr, "WARNING deadlocks may occur and extra memory allocating buffer sizes (packet_freelist_size) mismatched\n");
     
    14521452 * configuration structure.
    14531453 *
    1454  * @param libtrace The trace from which we determine the URI
    1455  * @param uc A configuration structure to be configured.
     1454 * @param[in,out] libtrace The trace from which we determine the URI and set
     1455 * the configuration.
    14561456 *
    14571457 * We search for 3 environment variables and apply them to the config in the
     
    14671467 * - test.erf would match LIBTRACE_CONF, LIBTRACE_CONF_ERF, LIBTRACE_CONF_ERF_TEST_ERF
    14681468 *
    1469  * @note All enironment variables names MUST only contian
     1469 * @note All environment variables names MUST only contian
    14701470 * [A-Z], [0-9] and [_] (underscore) and not start with a number. Any characters
    14711471 * outside of this range should be captilised if possible or replaced with an
    14721472 * underscore.
    14731473 */
    1474 static void parse_env_config (libtrace_t *libtrace, struct user_configuration* uc) {
     1474static void parse_env_config (libtrace_t *libtrace) {
    14751475        char env_name[1024] = "LIBTRACE_CONF_";
    14761476        size_t len = strlen(env_name);
     
    15031503        {
    15041504                printf("Got env %s", env);
    1505                 parse_user_config(uc, env);
     1505                trace_set_configuration(libtrace, env);
    15061506        }
    15071507
     
    15121512                if (env) {
    15131513                        printf("Got %s=%s", env_name, env);
    1514                         parse_user_config(uc, env);
     1514                        trace_set_configuration(libtrace, env);
    15151515                }
    15161516                env_name[mark] = '_';
     
    15211521        if (env) {
    15221522                printf("Got %s=%s", env_name, env);
    1523                 parse_user_config(uc, env);
     1523                trace_set_configuration(libtrace, env);
    15241524        }
    15251525}
     
    15691569
    15701570        /* Parses configuration passed through environment variables */
    1571         parse_env_config(libtrace, &libtrace->config);
     1571        parse_env_config(libtrace);
    15721572        verify_configuration(libtrace);
    15731573
     
    16671667                             (void* (*)()) trace_create_packet,
    16681668                             (void (*)(void *))trace_destroy_packet,
    1669                              libtrace->config.packet_thread_cache_size,
    1670                              libtrace->config.packet_cache_size * 4,
    1671                              libtrace->config.fixed_packet_count) != 0) {
     1669                             libtrace->config.thread_cache_size,
     1670                             libtrace->config.cache_size * 4,
     1671                             libtrace->config.fixed_count) != 0) {
    16721672                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "trace_pstart "
    16731673                              "failed to allocate ocache.");
     
    19171917        // there is a more efficient way to apply it, in this case
    19181918        // it will simply grab the function out of libtrace_t
    1919         if (trace->format->pconfig_input)
    1920                 ret = trace->format->pconfig_input(trace, TRACE_OPTION_SET_HASHER, &type);
     1919        if (trace->format->config_input)
     1920                ret = trace->format->config_input(trace, TRACE_OPTION_HASHER, &type);
    19211921
    19221922        if (ret == -1) {
     
    21622162}
    21632163
    2164 DLLEXPORT int trace_parallel_config(libtrace_t *libtrace, trace_parallel_option_t option, void *value)
    2165 {
    2166         UNUSED int ret = -1;
    2167         switch (option) {
    2168                 case TRACE_OPTION_TICK_INTERVAL:
    2169                         libtrace->config.tick_interval = *((int *) value);
    2170                         return 1;
    2171                 case TRACE_OPTION_SET_HASHER:
    2172                         return trace_set_hasher(libtrace, (enum hasher_types) *((int *) value), NULL, NULL);
    2173                 case TRACE_OPTION_SET_PERPKT_THREAD_COUNT:
    2174                         libtrace->config.perpkt_threads = *((int *) value);
    2175                         return 1;
    2176                 case TRACE_OPTION_TRACETIME:
    2177                         if(*((int *) value))
    2178                                 libtrace->tracetime = 1;
    2179                         else
    2180                                 libtrace->tracetime = 0;
    2181                         return 0;
    2182                 case TRACE_OPTION_SET_CONFIG:
    2183                         libtrace->config = *((struct user_configuration *) value);
    2184                 case TRACE_OPTION_GET_CONFIG:
    2185                         *((struct user_configuration *) value) = libtrace->config;
    2186         }
     2164/**
     2165 * @return True if the trace is not running such that it can be configured
     2166 */
     2167static inline bool trace_is_configurable(libtrace_t *trace) {
     2168        return trace->state == STATE_NEW ||
     2169                        trace->state == STATE_PAUSED;
     2170}
     2171
     2172DLLEXPORT int trace_set_perpkt_threads(libtrace_t *trace, int nb) {
     2173        if (!trace_is_configurable(trace)) return -1;
     2174
     2175        /* TODO consider allowing an offset from the total number of cores i.e.
     2176         * -1 reserve 1 core */
     2177        if (nb >= 0) {
     2178                trace->config.perpkt_threads = nb;
     2179                return 0;
     2180        } else {
     2181                return -1;
     2182        }
     2183}
     2184
     2185DLLEXPORT int trace_set_tick_interval(libtrace_t *trace, size_t interval) {
     2186        if (!trace_is_configurable(trace)) return -1;
     2187
     2188        trace->config.tick_interval = interval;
    21872189        return 0;
    21882190}
     2191
     2192DLLEXPORT int trace_set_tick_count(libtrace_t *trace, size_t count) {
     2193        if (!trace_is_configurable(trace)) return -1;
     2194
     2195        trace->config.tick_count = count;
     2196        return 0;
     2197}
     2198
     2199DLLEXPORT int trace_set_tracetime(libtrace_t *trace, bool tracetime) {
     2200        if (!trace_is_configurable(trace)) return -1;
     2201
     2202        trace->tracetime = tracetime;
     2203        return 0;
     2204}
     2205
     2206DLLEXPORT int trace_set_cache_size(libtrace_t *trace, size_t size) {
     2207        if (!trace_is_configurable(trace)) return -1;
     2208
     2209        trace->config.cache_size = size;
     2210        return 0;
     2211}
     2212
     2213DLLEXPORT int trace_set_thread_cache_size(libtrace_t *trace, size_t size) {
     2214        if (!trace_is_configurable(trace)) return -1;
     2215
     2216        trace->config.thread_cache_size = size;
     2217        return 0;
     2218}
     2219
     2220DLLEXPORT int trace_set_fixed_count(libtrace_t *trace, bool fixed) {
     2221        if (!trace_is_configurable(trace)) return -1;
     2222
     2223        trace->config.fixed_count = fixed;
     2224        return 0;
     2225}
     2226
     2227DLLEXPORT int trace_set_burst_size(libtrace_t *trace, size_t size) {
     2228        if (!trace_is_configurable(trace)) return -1;
     2229
     2230        trace->config.burst_size = size;
     2231        return 0;
     2232}
     2233
     2234DLLEXPORT int trace_set_hasher_queue_size(libtrace_t *trace, size_t size) {
     2235        if (!trace_is_configurable(trace)) return -1;
     2236
     2237        trace->config.hasher_queue_size = size;
     2238        return 0;
     2239}
     2240
     2241DLLEXPORT int trace_set_hasher_polling(libtrace_t *trace, bool polling) {
     2242        if (!trace_is_configurable(trace)) return -1;
     2243
     2244        trace->config.hasher_polling = polling;
     2245        return 0;
     2246}
     2247
     2248DLLEXPORT int trace_set_reporter_polling(libtrace_t *trace, bool polling) {
     2249        if (!trace_is_configurable(trace)) return -1;
     2250
     2251        trace->config.reporter_polling = polling;
     2252        return 0;
     2253}
     2254
     2255DLLEXPORT int trace_set_reporter_thold(libtrace_t *trace, size_t thold) {
     2256        if (!trace_is_configurable(trace)) return -1;
     2257
     2258        trace->config.reporter_thold = thold;
     2259        return 0;
     2260}
     2261
     2262DLLEXPORT int trace_set_debug_state(libtrace_t *trace, bool debug_state) {
     2263        if (!trace_is_configurable(trace)) return -1;
     2264
     2265        trace->config.debug_state = debug_state;
     2266        return 0;
     2267}
     2268
     2269
    21892270
    21902271static bool config_bool_parse(char *value, size_t nvalue) {
     
    21972278}
    21982279
     2280/* Note update documentation on trace_set_configuration */
    21992281static void config_string(struct user_configuration *uc, char *key, size_t nkey, char *value, size_t nvalue) {
    22002282        assert(key);
    22012283        assert(value);
    22022284        assert(uc);
    2203         if (strncmp(key, "packet_cache_size", nkey) == 0
    2204             || strncmp(key, "pcs", nkey) == 0) {
    2205                 uc->packet_cache_size = strtoll(value, NULL, 10);
    2206         } else if (strncmp(key, "packet_thread_cache_size", nkey) == 0
    2207                    || strncmp(key, "ptcs", nkey) == 0) {
    2208                 uc->packet_thread_cache_size = strtoll(value, NULL, 10);
    2209         } else if (strncmp(key, "fixed_packet_count", nkey) == 0
    2210                    || strncmp(key, "fpc", nkey) == 0) {
    2211                 uc->fixed_packet_count = config_bool_parse(value, nvalue);
     2285        if (strncmp(key, "cache_size", nkey) == 0
     2286            || strncmp(key, "cs", nkey) == 0) {
     2287                uc->cache_size = strtoll(value, NULL, 10);
     2288        } else if (strncmp(key, "thread_cache_size", nkey) == 0
     2289                   || strncmp(key, "tcs", nkey) == 0) {
     2290                uc->thread_cache_size = strtoll(value, NULL, 10);
     2291        } else if (strncmp(key, "fixed_count", nkey) == 0
     2292                   || strncmp(key, "fc", nkey) == 0) {
     2293                uc->fixed_count = config_bool_parse(value, nvalue);
    22122294        } else if (strncmp(key, "burst_size", nkey) == 0
    22132295                   || strncmp(key, "bs", nkey) == 0) {
     
    22422324}
    22432325
    2244 DLLEXPORT void parse_user_config(struct user_configuration* uc, char * str) {
     2326DLLEXPORT int trace_set_configuration(libtrace_t *trace, const char *str) {
    22452327        char *pch;
    22462328        char key[100];
    22472329        char value[100];
     2330        char *dup;
    22482331        assert(str);
    2249         assert(uc);
    2250         pch = strtok (str," ,.-");
     2332        assert(trace);
     2333
     2334        if (!trace_is_configurable(trace)) return -1;
     2335
     2336        dup = strdup(str);
     2337        pch = strtok (dup," ,.-");
    22512338        while (pch != NULL)
    22522339        {
    22532340                if (sscanf(pch, "%99[^=]=%99s", key, value) == 2) {
    2254                         config_string(uc, key, sizeof(key), value, sizeof(value));
     2341                        config_string(&trace->config, key, sizeof(key), value, sizeof(value));
    22552342                } else {
    22562343                        fprintf(stderr, "Error parsing %s\n", pch);
     
    22582345                pch = strtok (NULL," ,.-");
    22592346        }
    2260 }
    2261 
    2262 DLLEXPORT void parse_user_config_file(struct user_configuration* uc, FILE *file) {
     2347        free(dup);
     2348
     2349        return 0;
     2350}
     2351
     2352DLLEXPORT int trace_set_configuration_file(libtrace_t *trace, FILE *file) {
    22632353        char line[1024];
     2354        if (!trace_is_configurable(trace)) return -1;
     2355
    22642356        while (fgets(line, sizeof(line), file) != NULL)
    22652357        {
    2266                 parse_user_config(uc, line);
    2267         }
     2358                trace_set_configuration(trace, line);
     2359        }
     2360
     2361        if(ferror(file))
     2362                return -1;
     2363        else
     2364                return 0;
    22682365}
    22692366
Note: See TracChangeset for help on using the changeset viewer.