lighttpd
/
lighttpd1.4
2
0
Fork 0
Code Issues Releases Wiki Activity
lighttpd1.4/src/array.c

664 lines
21 KiB
C
Raw Normal View History

consistent inclusion of config.h at top of files (fixes #2073) From: Glenn Strauss <gstrauss@gluelogic.com> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3113 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-19 15:14:35 +00:00
#include "first.h"
Fix header inclusion order, always include "config.h" before any system header git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2624 152afb58-edef-0310-8abb-c4023f1b3aa9
2009-10-11 14:31:42 +00:00
#include "array.h"
#include "buffer.h"
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
#include <string.h>
#include <stdlib.h>
#include <limits.h>
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
__attribute_cold__
static data_unset *array_data_string_copy(const data_unset *s) {
data_string *src = (data_string *)s;
data_string *ds = array_data_string_init();
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (!buffer_is_unset(&src->key)) buffer_copy_buffer(&ds->key, &src->key);
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
buffer_copy_buffer(&ds->value, &src->value);
return (data_unset *)ds;
}
__attribute_cold__
static void array_data_string_insert_dup(data_unset *dst, data_unset *src) {
data_string *ds_dst = (data_string *)dst;
data_string *ds_src = (data_string *)src;
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (!buffer_is_blank(&ds_dst->value))
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
buffer_append_str2(&ds_dst->value, CONST_STR_LEN(", "),
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
BUF_PTR_LEN(&ds_src->value));
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
else
buffer_copy_buffer(&ds_dst->value, &ds_src->value);
}
static void array_data_string_free(data_unset *du) {
data_string *ds = (data_string *)du;
free(ds->key.ptr);
free(ds->value.ptr);
free(ds);
}
__attribute_noinline__
data_string *array_data_string_init(void) {
static const struct data_methods fn = {
array_data_string_copy,
array_data_string_free,
array_data_string_insert_dup,
};
data_string *ds = calloc(1, sizeof(*ds));
force_assert(NULL != ds);
ds->type = TYPE_STRING;
ds->fn = &fn;
return ds;
}
__attribute_cold__
static data_unset *array_data_integer_copy(const data_unset *s) {
data_integer *src = (data_integer *)s;
data_integer *di = array_data_integer_init();
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (!buffer_is_unset(&src->key)) buffer_copy_buffer(&di->key, &src->key);
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
di->value = src->value;
return (data_unset *)di;
}
static void array_data_integer_free(data_unset *du) {
data_integer *di = (data_integer *)du;
free(di->key.ptr);
free(di);
}
__attribute_noinline__
data_integer *array_data_integer_init(void) {
static const struct data_methods fn = {
array_data_integer_copy,
array_data_integer_free,
[core] make insert_dup an optional array method make insert_dup an optional array method in data_methods (currently used only for merging strings of type data_string)
2021-05-23 00:34:58 +00:00
NULL
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
};
data_integer *di = calloc(1, sizeof(*di));
force_assert(NULL != di);
di->type = TYPE_INTEGER;
di->fn = &fn;
return di;
}
__attribute_cold__
static data_unset *array_data_array_copy(const data_unset *s) {
data_array *src = (data_array *)s;
data_array *da = array_data_array_init();
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (!buffer_is_unset(&src->key)) buffer_copy_buffer(&da->key, &src->key);
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
array_copy_array(&da->value, &src->value);
return (data_unset *)da;
}
static void array_data_array_free(data_unset *du) {
data_array *da = (data_array *)du;
free(da->key.ptr);
array_free_data(&da->value);
free(da);
}
__attribute_noinline__
data_array *array_data_array_init(void) {
static const struct data_methods fn = {
array_data_array_copy,
array_data_array_free,
[core] make insert_dup an optional array method make insert_dup an optional array method in data_methods (currently used only for merging strings of type data_string)
2021-05-23 00:34:58 +00:00
NULL
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
};
data_array *da = calloc(1, sizeof(*da));
force_assert(NULL != da);
da->type = TYPE_ARRAY;
da->fn = &fn;
return da;
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
__attribute_cold__
[core] array_init() arg for initial size
2019-11-22 05:57:48 +00:00
static void array_extend(array * const a, uint32_t n) {
[core] adjust some array code (better asm) slightly reorganize some code for better asm
2021-05-18 19:19:55 +00:00
/* This data structure should not be used for nearly so many entries */
force_assert(a->size <= INT32_MAX-n);
[core] array_init() arg for initial size
2019-11-22 05:57:48 +00:00
a->size += n;
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
a->data = realloc(a->data, sizeof(*a->data) * a->size);
[core] keep a->data[] sorted (REVERT) This reverts commit 2260a8062ee599ecf28d9b52b981603fd2084aff. original ordering of array elements is significant e.g. in lighttpd.conf lists where first match to request is applied
2019-10-14 05:44:06 +00:00
a->sorted = realloc(a->sorted, sizeof(*a->sorted) * a->size);
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
force_assert(a->data);
[core] keep a->data[] sorted (REVERT) This reverts commit 2260a8062ee599ecf28d9b52b981603fd2084aff. original ordering of array elements is significant e.g. in lighttpd.conf lists where first match to request is applied
2019-10-14 05:44:06 +00:00
force_assert(a->sorted);
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
memset(a->data+a->used, 0, (a->size-a->used)*sizeof(*a->data));
}
[core] refactor array search; raise array size limit to SSIZE_MAX - raise array size limit from INT_MAX to SSIZE_MAX. INT_MAX already is way to high to be hit in any sane scenario, but SSIZE_MAX can *obviously* not be hit due to memory constraints. - use size_t for array indices instead of int - use binary search instead of next_power_of_2 hack; document invariants and check them in debug mode (asserts). - return the actual insert position instead of something near From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3100 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:41:57 +00:00
[core] array_init() arg for initial size
2019-11-22 05:57:48 +00:00
array *array_init(uint32_t n) {
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
array *a;
- white space cleanup part 2 this time 1.4 ;) i hope it helps with merging stuff back to 1.5 git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@1371 152afb58-edef-0310-8abb-c4023f1b3aa9
2006-10-04 13:26:23 +00:00
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
a = calloc(1, sizeof(*a));
add force_assert() to enforce assertions as simple assert()s are disabled by -DNDEBUG (fixes #2546) From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2948 152afb58-edef-0310-8abb-c4023f1b3aa9
2014-02-16 13:08:20 +00:00
force_assert(a);
[core] array_init() arg for initial size
2019-11-22 05:57:48 +00:00
if (n) array_extend(a, n);
- white space cleanup part 2 this time 1.4 ;) i hope it helps with merging stuff back to 1.5 git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@1371 152afb58-edef-0310-8abb-c4023f1b3aa9
2006-10-04 13:26:23 +00:00
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
return a;
}
[core] inline array as part of data_array value (instead of value being (array *))
2019-10-13 21:06:05 +00:00
void array_free_data(array * const a) {
[core] keep a->data[] sorted (REVERT) This reverts commit 2260a8062ee599ecf28d9b52b981603fd2084aff. original ordering of array elements is significant e.g. in lighttpd.conf lists where first match to request is applied
2019-10-14 05:44:06 +00:00
if (a->sorted) free(a->sorted);
[core] inline array as part of data_array value (instead of value being (array *))
2019-10-13 21:06:05 +00:00
data_unset ** const data = a->data;
const uint32_t sz = a->size;
for (uint32_t i = 0; i < sz; ++i) {
if (data[i]) data[i]->fn->free(data[i]);
}
free(data);
[multiple] plugin_stats array use global rather than passing around (server *) just for that li_itostrn() and li_utostrn() return string length (rather than requiring subsequent strlen() to find length)
2019-11-28 15:27:01 +00:00
a->data = NULL;
a->sorted = NULL;
a->used = 0;
a->size = 0;
[core] inline array as part of data_array value (instead of value being (array *))
2019-10-13 21:06:05 +00:00
}
user defined variable, compute on parsing: string+string, int+int, array+array, var+=expression. "include" sub configuration file. (merged ([308], [309], [306], [305]) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-merge-1.4.x@520 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-08-08 14:40:47 +00:00
[core] inline array as part of data_array value (instead of value being (array *))
2019-10-13 21:06:05 +00:00
void array_copy_array(array * const dst, const array * const src) {
array_free_data(dst);
if (0 == src->size) return;
fix/silence bugs reported by ccc-analyzer (clang) These should all be non critical: * memory leaks on startup in error cases (which lead to immediate shutdowns anyway) * http_auth/ldap: passing uninitialized "ret" to ldap_err2string * sizeof(T) not matching the target pointer in malloc/calloc calls; those cases were either: * T being the wrong pointer type - shouldn't matter as long as all pointers have same size * T being larger than the type needed * mod_accesslog: direct use after free in cleanup (server shutdown); could crash before "clean" shutdown * some false positives (mod_compress, mod_expire) * assert(srv->config_context->used > 0); - this is always the case, as there is always a global config block From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2920 152afb58-edef-0310-8abb-c4023f1b3aa9
2013-11-13 11:43:26 +00:00
[core] fix array_copy_array() sorted[] fix array_copy_array() sorted[] (current use appears to be only on value lists; not user-visible issue) Some time back, sorted[] was a set of indexes into data[], and therefore sorted[] could be copied when copying array. Now that sorted[] is a list of pointers, the sorted[] list must be rebuilt. If copied, it continued to point to (data_unset *) from the original src array, not the dst array.
2020-12-16 01:01:23 +00:00
array_extend(dst, src->size);
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
for (uint32_t i = 0; i < src->used; ++i) {
[core] fix array_copy_array() sorted[] fix array_copy_array() sorted[] (current use appears to be only on value lists; not user-visible issue) Some time back, sorted[] was a set of indexes into data[], and therefore sorted[] could be copied when copying array. Now that sorted[] is a list of pointers, the sorted[] list must be rebuilt. If copied, it continued to point to (data_unset *) from the original src array, not the dst array.
2020-12-16 01:01:23 +00:00
array_insert_unique(dst, src->data[i]->fn->copy(src->data[i]));
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
}
user defined variable, compute on parsing: string+string, int+int, array+array, var+=expression. "include" sub configuration file. (merged ([308], [309], [306], [305]) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-merge-1.4.x@520 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-08-08 14:40:47 +00:00
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
void array_free(array * const a) {
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
if (!a) return;
[core] inline array as part of data_array value (instead of value being (array *))
2019-10-13 21:06:05 +00:00
array_free_data(a);
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
free(a);
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
void array_reset_data_strings(array * const a) {
[core] perf: array_reset_data_strings() array_reset_data_strings() specialization
2018-10-23 00:28:53 +00:00
if (!a) return;
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
data_string ** const data = (data_string **)a->data;
const uint32_t used = a->used;
a->used = 0;
for (uint32_t i = 0; i < used; ++i) {
data_string * const ds = data[i];
[core] perf: array_reset_data_strings() array_reset_data_strings() specialization
2018-10-23 00:28:53 +00:00
/*force_assert(ds->type == TYPE_STRING);*/
[core] inline buffer_reset() buffer_reset() is used on pre-allocated buffers, so remove NULL check
2020-08-10 23:46:17 +00:00
buffer_reset(&ds->key);
buffer_reset(&ds->value);
[core] perf: array_reset_data_strings() array_reset_data_strings() specialization
2018-10-23 00:28:53 +00:00
}
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
#if 0 /*(unused; see array_extract_element_klen())*/
data_unset *array_pop(array * const a) {
added nested conditionals (merged [298]) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-merge-1.4.x@519 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-08-08 13:48:33 +00:00
data_unset *du;
add force_assert() to enforce assertions as simple assert()s are disabled by -DNDEBUG (fixes #2546) From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2948 152afb58-edef-0310-8abb-c4023f1b3aa9
2014-02-16 13:08:20 +00:00
force_assert(a->used != 0);
added nested conditionals (merged [298]) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-merge-1.4.x@519 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-08-08 13:48:33 +00:00
a->used --;
du = a->data[a->used];
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
force_assert(a->sorted[a->used] == du); /* only works on "simple" lists */
added nested conditionals (merged [298]) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-merge-1.4.x@519 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-08-08 13:48:33 +00:00
a->data[a->used] = NULL;
return du;
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
#endif
added nested conditionals (merged [298]) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-merge-1.4.x@519 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-08-08 13:48:33 +00:00
[core] array-specialized buffer_caseless_compare() specialize buffer_caseless_compare() for array.c
2019-06-05 01:16:58 +00:00
__attribute_pure__
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
static int array_caseless_compare(const char * const a, const char * const b, const uint32_t len) {
for (uint32_t i = 0; i < len; ++i) {
[core] array-specialized buffer_caseless_compare() specialize buffer_caseless_compare() for array.c
2019-06-05 01:16:58 +00:00
unsigned int ca = ((unsigned char *)a)[i];
unsigned int cb = ((unsigned char *)b)[i];
if (ca == cb) continue;
/* always lowercase for transitive results */
[core] light_isupper(), light_islower() more efficient char checks (replace one comparision and one branch with one subtraction)
2020-09-10 04:15:29 +00:00
if (light_isupper(ca)) ca |= 0x20;
if (light_isupper(cb)) cb |= 0x20;
[core] array-specialized buffer_caseless_compare() specialize buffer_caseless_compare() for array.c
2019-06-05 01:16:58 +00:00
if (ca == cb) continue;
return (int)(ca - cb);
}
return 0;
}
__attribute_pure__
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
static int array_keycmp(const char * const a, const uint32_t alen, const char * const b, const uint32_t blen) {
[core] array-specialized buffer_caseless_compare() specialize buffer_caseless_compare() for array.c
2019-06-05 01:16:58 +00:00
return alen < blen ? -1 : alen > blen ? 1 : array_caseless_compare(a, b, blen);
[core] perf: specialized func for array sorting specialized func for array sorting for use in binary search
2018-10-27 05:36:03 +00:00
}
[core] extend (data_string *) to store header id (optional addition to (data_string *), used by http_header.[ch]) extend (data_string *) instead of creating another data_* TYPE_* (new data type would probably have (data_string *) as base class) (might revisit choice in the future) HTTP_HEADER_UNSPECIFIED has been removed. It was used in select locations as an optimization to avoid looking up enum header_header_e before checking the array, but the ordering in the array now relies on having the id. Having the id allows for a quick check if a common header is present or not in the htags bitmask, before checking the array, and allows for integer comparison in the log(n) search of the array, instead of strncasecmp(). With HTTP_HEADER_UNSPECIFIED removed, add optimization to set bit in htags for HTTP_HEADER_OTHER when an "other" header is added, but do not clear the bit, as there might be addtl "other" headers
2020-09-11 21:25:43 +00:00
__attribute_cold__
__attribute_pure__
static int array_keycmpb(const char * const k, const uint32_t klen, const buffer * const b) {
/* key is non-empty (0==b->used), though possibly blank (1==b->used)
* if inserted into key-value array */
/*force_assert(b && b->used);*/
return array_keycmp(k, klen, b->ptr, b->used-1);
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
/*return array_keycmp(k, klen, BUF_PTR_LEN(b));*/
[core] extend (data_string *) to store header id (optional addition to (data_string *), used by http_header.[ch]) extend (data_string *) instead of creating another data_* TYPE_* (new data type would probably have (data_string *) as base class) (might revisit choice in the future) HTTP_HEADER_UNSPECIFIED has been removed. It was used in select locations as an optimization to avoid looking up enum header_header_e before checking the array, but the ordering in the array now relies on having the id. Having the id allows for a quick check if a common header is present or not in the htags bitmask, before checking the array, and allows for integer comparison in the log(n) search of the array, instead of strncasecmp(). With HTTP_HEADER_UNSPECIFIED removed, add optimization to set bit in htags for HTTP_HEADER_OTHER when an "other" header is added, but do not clear the bit, as there might be addtl "other" headers
2020-09-11 21:25:43 +00:00
}
/* returns pos into a->sorted[] which contains copy of data (ptr) in a->data[]
* if pos >= 0, or returns -pos-1 if that is the position-1 in a->sorted[]
* where the key needs to be inserted (-1 to avoid -0)
*/
__attribute_hot__
__attribute_pure__
static int32_t array_get_index_ext(const array * const a, const int ext, const char * const k, const uint32_t klen) {
/* invariant: [lower-1] < probe < [upper]
* invariant: 0 <= lower <= upper <= a->used
*/
uint32_t lower = 0, upper = a->used;
while (lower != upper) {
const uint32_t probe = (lower + upper) / 2;
const int x = ((data_string *)a->sorted[probe])->ext;
/* (compare strings only if ext is 0 for both)*/
const int e = (ext|x)
? ext
: array_keycmpb(k, klen, &a->sorted[probe]->key);
if (e < x) /* e < [probe] */
upper = probe; /* still: lower <= upper */
else if (e > x) /* e > [probe] */
lower = probe + 1; /* still: lower <= upper */
else /*(e == x)*/ /* found */
return (int32_t)probe;
}
/* not found: [lower-1] < key < [upper] = [lower] ==> insert at [lower] */
return -(int)lower - 1;
}
data_unset *array_get_element_klen_ext(const array * const a, const int ext, const char *key, const uint32_t klen) {
const int32_t ipos = array_get_index_ext(a, ext, key, klen);
return ipos >= 0 ? a->sorted[ipos] : NULL;
}
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
/* returns pos into a->sorted[] which contains copy of data (ptr) in a->data[]
[core] keep a->data[] sorted (REVERT) This reverts commit 2260a8062ee599ecf28d9b52b981603fd2084aff. original ordering of array elements is significant e.g. in lighttpd.conf lists where first match to request is applied
2019-10-14 05:44:06 +00:00
* if pos >= 0, or returns -pos-1 if that is the position-1 in a->sorted[]
* where the key needs to be inserted (-1 to avoid -0)
[core] refactor array search; raise array size limit to SSIZE_MAX - raise array size limit from INT_MAX to SSIZE_MAX. INT_MAX already is way to high to be hit in any sane scenario, but SSIZE_MAX can *obviously* not be hit due to memory constraints. - use size_t for array indices instead of int - use binary search instead of next_power_of_2 hack; document invariants and check them in debug mode (asserts). - return the actual insert position instead of something near From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3100 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:41:57 +00:00
*/
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
__attribute_hot__
__attribute_pure__
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
static int32_t array_get_index(const array * const a, const char * const k, const uint32_t klen) {
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
/* invariant: [lower-1] < probe < [upper]
* invariant: 0 <= lower <= upper <= a->used
*/
uint32_t lower = 0, upper = a->used;
while (lower != upper) {
uint32_t probe = (lower + upper) / 2;
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
const buffer * const b = &a->sorted[probe]->key;
[core] array keys are non-empty in key-value list
2019-10-06 20:05:00 +00:00
/* key is non-empty (0==b->used), though possibly blank (1==b->used),
* if inserted into key-value array */
/*force_assert(b && b->used);*/
int cmp = array_keycmp(k, klen, b->ptr, b->used-1);
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
/*int cmp = array_keycmp(k, klen, BUF_PTR_LEN(b));*/
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
if (cmp < 0) /* key < [probe] */
upper = probe; /* still: lower <= upper */
else if (cmp > 0) /* key > [probe] */
lower = probe + 1; /* still: lower <= upper */
else /*(cmp == 0)*/ /* found */
return (int32_t)probe;
}
/* not found: [lower-1] < key < [upper] = [lower] ==> insert at [lower] */
return -(int)lower - 1;
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
__attribute_hot__
[core] const data_unset *array_get_element_klen() return (const data_unset *) from array_get_element_klen(); use array_get_data_unset() for non-const (note: marked attribute cold)
2021-01-26 19:23:42 +00:00
const data_unset *array_get_element_klen(const array * const a, const char *key, const uint32_t klen) {
[core] differentiate array_get_* for ro and rw array_get_element_klen() is now intended for read-only access array_get_data_unset() is used by config processing for r/w access array_get_buf_ptr() is used for r/w access to ds->value (string buffer)
2019-10-10 03:24:25 +00:00
const int32_t ipos = array_get_index(a, key, klen);
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
return ipos >= 0 ? a->sorted[ipos] : NULL;
[core] differentiate array_get_* for ro and rw array_get_element_klen() is now intended for read-only access array_get_data_unset() is used by config processing for r/w access array_get_buf_ptr() is used for r/w access to ds->value (string buffer)
2019-10-10 03:24:25 +00:00
}
/* non-const (data_config *) for configparser.y (not array_get_element_klen())*/
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
data_unset *array_get_data_unset(const array * const a, const char *key, const uint32_t klen) {
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
const int32_t ipos = array_get_index(a, key, klen);
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
return ipos >= 0 ? a->sorted[ipos] : NULL;
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
}
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
data_unset *array_extract_element_klen(array * const a, const char *key, const uint32_t klen) {
[core] keep a->data[] sorted; remove a->sorted[]
2019-10-06 21:57:11 +00:00
const int32_t ipos = array_get_index(a, key, klen);
if (ipos < 0) return NULL;
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
/* remove entry from a->sorted: move everything after pos one step left */
data_unset * const entry = a->sorted[ipos];
[core] keep a->data[] sorted; remove a->sorted[]
2019-10-06 21:57:11 +00:00
const uint32_t last_ndx = --a->used;
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
if (last_ndx != (uint32_t)ipos) {
data_unset ** const d = a->sorted + ipos;
memmove(d, d+1, (last_ndx - (uint32_t)ipos) * sizeof(*d));
}
[core] keep a->data[] sorted (REVERT) This reverts commit 2260a8062ee599ecf28d9b52b981603fd2084aff. original ordering of array elements is significant e.g. in lighttpd.conf lists where first match to request is applied
2019-10-14 05:44:06 +00:00
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
if (entry != a->data[last_ndx]) {
/* walk a->data[] to find data ptr */
/* (not checking (ndx <= last_ndx) since entry must be in a->data[]) */
uint32_t ndx = 0;
while (entry != a->data[ndx]) ++ndx;
a->data[ndx] = a->data[last_ndx]; /* swap with last element */
}
[core] keep a->data[] sorted; remove a->sorted[]
2019-10-06 21:57:11 +00:00
a->data[last_ndx] = NULL;
return entry;
[core] provide array_extract_element and use it From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3102 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:56:02 +00:00
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
static data_unset *array_get_unused_element(array * const a, const data_type_t t) {
[multiple] correct misspellings in comments x-ref: "Script for fixing spelling errors with codespell" https://redmine.lighttpd.net/boards/3/topics/8947
2020-02-22 22:24:12 +00:00
/* After initial startup and config, most array usage is of homogeneous types
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
* and arrays are cleared once per request, so check only the first unused
* element to see if it can be reused */
#if 1
data_unset * const du = (a->used < a->size) ? a->data[a->used] : NULL;
if (NULL != du && du->type == t) {
a->data[a->used] = NULL;/* make empty slot at a->used for next insert */
return du;
}
return NULL;
#else
data_unset ** const data = a->data;
for (uint32_t i = a->used, sz = a->size; i < sz; ++i) {
if (data[i] && data[i]->type == t) {
data_unset * const ds = data[i];
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
array.c: improve array_get_unused_element to check data type; fix mem leak if unused_element didn't find a matching entry (fixes #2145) - the "mem leak" could only be triggered if you use different entry types in the same array (this wasn't supported by array_get_unused_element) or didn't call array_get_unused_element before creating new entries. git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2750 152afb58-edef-0310-8abb-c4023f1b3aa9
2010-08-05 21:08:23 +00:00
/* make empty slot at a->used for next insert */
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
data[i] = data[a->used];
data[a->used] = NULL;
- white space cleanup part 2 this time 1.4 ;) i hope it helps with merging stuff back to 1.5 git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@1371 152afb58-edef-0310-8abb-c4023f1b3aa9
2006-10-04 13:26:23 +00:00
array.c: improve array_get_unused_element to check data type; fix mem leak if unused_element didn't find a matching entry (fixes #2145) - the "mem leak" could only be triggered if you use different entry types in the same array (this wasn't supported by array_get_unused_element) or didn't call array_get_unused_element before creating new entries. git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2750 152afb58-edef-0310-8abb-c4023f1b3aa9
2010-08-05 21:08:23 +00:00
return ds;
}
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
}
- white space cleanup part 2 this time 1.4 ;) i hope it helps with merging stuff back to 1.5 git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@1371 152afb58-edef-0310-8abb-c4023f1b3aa9
2006-10-04 13:26:23 +00:00
array.c: improve array_get_unused_element to check data type; fix mem leak if unused_element didn't find a matching entry (fixes #2145) - the "mem leak" could only be triggered if you use different entry types in the same array (this wasn't supported by array_get_unused_element) or didn't call array_get_unused_element before creating new entries. git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2750 152afb58-edef-0310-8abb-c4023f1b3aa9
2010-08-05 21:08:23 +00:00
return NULL;
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
#endif
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
}
[core] extend (data_string *) to store header id (optional addition to (data_string *), used by http_header.[ch]) extend (data_string *) instead of creating another data_* TYPE_* (new data type would probably have (data_string *) as base class) (might revisit choice in the future) HTTP_HEADER_UNSPECIFIED has been removed. It was used in select locations as an optimization to avoid looking up enum header_header_e before checking the array, but the ordering in the array now relies on having the id. Having the id allows for a quick check if a common header is present or not in the htags bitmask, before checking the array, and allows for integer comparison in the log(n) search of the array, instead of strncasecmp(). With HTTP_HEADER_UNSPECIFIED removed, add optimization to set bit in htags for HTTP_HEADER_OTHER when an "other" header is added, but do not clear the bit, as there might be addtl "other" headers
2020-09-11 21:25:43 +00:00
__attribute_hot__
[core] return entry from array_insert_data_at_pos (for convenience and to save a couple asm instructions)
2021-05-23 02:30:17 +00:00
static data_unset * array_insert_data_at_pos(array * const a, data_unset * const entry, const uint_fast32_t pos) {
[core] adjust some array code (better asm) slightly reorganize some code for better asm
2021-05-18 19:19:55 +00:00
if (a->used < a->size) {
data_unset * const prev = a->data[a->used];
if (__builtin_expect( (prev != NULL), 0))
prev->fn->free(prev); /* free prior data, if any, from slot */
}
else {
[core] array_init() arg for initial size
2019-11-22 05:57:48 +00:00
array_extend(a, 16);
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
}
Add "lighty.req_env" table to mod_magnet for setting/getting environment values for cgi (fixes #1967, thx presbrey) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2515 152afb58-edef-0310-8abb-c4023f1b3aa9
2009-06-10 13:08:15 +00:00
[core] return entry from array_insert_data_at_pos (for convenience and to save a couple asm instructions)
2021-05-23 02:30:17 +00:00
uint_fast32_t ndx = a->used++;
[core] keep a->data[] sorted (REVERT) This reverts commit 2260a8062ee599ecf28d9b52b981603fd2084aff. original ordering of array elements is significant e.g. in lighttpd.conf lists where first match to request is applied
2019-10-14 05:44:06 +00:00
a->data[ndx] = entry;
[core] code reuse with array_insert_key_value() code reuse with array_insert_key_value() and related array manipulation
2018-09-08 18:23:23 +00:00
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
/* move everything one step to the right */
[core] return entry from array_insert_data_at_pos (for convenience and to save a couple asm instructions)
2021-05-23 02:30:17 +00:00
ndx -= pos;
data_unset ** const d = a->sorted + pos;
if (__builtin_expect( (ndx), 1))
memmove(d+1, d, ndx * sizeof(*a->sorted));
*d = entry;
return entry;
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
}
[core] code reuse with array_insert_key_value() code reuse with array_insert_key_value() and related array manipulation
2018-09-08 18:23:23 +00:00
[core] return entry from array_insert_data_at_pos (for convenience and to save a couple asm instructions)
2021-05-23 02:30:17 +00:00
static data_integer * array_insert_integer_at_pos(array * const a, const uint_fast32_t pos) {
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
#if 0 /*(not currently used by lighttpd in way that reuse would occur)*/
data_integer *di = (data_integer *)array_get_unused_element(a,TYPE_INTEGER);
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
if (NULL == di) di = array_data_integer_init();
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
#else
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
data_integer * const di = array_data_integer_init();
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
#endif
[core] return entry from array_insert_data_at_pos (for convenience and to save a couple asm instructions)
2021-05-23 02:30:17 +00:00
return (data_integer *)array_insert_data_at_pos(a, (data_unset *)di, pos);
[core] code reuse with array_insert_key_value() code reuse with array_insert_key_value() and related array manipulation
2018-09-08 18:23:23 +00:00
}
[core] extend (data_string *) to store header id (optional addition to (data_string *), used by http_header.[ch]) extend (data_string *) instead of creating another data_* TYPE_* (new data type would probably have (data_string *) as base class) (might revisit choice in the future) HTTP_HEADER_UNSPECIFIED has been removed. It was used in select locations as an optimization to avoid looking up enum header_header_e before checking the array, but the ordering in the array now relies on having the id. Having the id allows for a quick check if a common header is present or not in the htags bitmask, before checking the array, and allows for integer comparison in the log(n) search of the array, instead of strncasecmp(). With HTTP_HEADER_UNSPECIFIED removed, add optimization to set bit in htags for HTTP_HEADER_OTHER when an "other" header is added, but do not clear the bit, as there might be addtl "other" headers
2020-09-11 21:25:43 +00:00
__attribute_hot__
[core] return entry from array_insert_data_at_pos (for convenience and to save a couple asm instructions)
2021-05-23 02:30:17 +00:00
static data_string * array_insert_string_at_pos(array * const a, const uint_fast32_t pos) {
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
data_string *ds = (data_string *)array_get_unused_element(a, TYPE_STRING);
[core] move data_{array,integer,string} to array.c move native data_* types into array.c (the types are already declared in array.h) The array data structure remains extendable, as is done with data_config (configfile) and data_auth (mod_auth), though array data structure primary uses are at startup (config time) and header parsing. The insertion logic into sorted list can be expensive for large lists, so header parsing might choose a different data structure in the future.
2021-05-20 20:58:53 +00:00
if (NULL == ds) ds = array_data_string_init();
[core] return entry from array_insert_data_at_pos (for convenience and to save a couple asm instructions)
2021-05-23 02:30:17 +00:00
return (data_string *)array_insert_data_at_pos(a, (data_unset *)ds, pos);
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
}
[core] code reuse with array_insert_key_value() code reuse with array_insert_key_value() and related array manipulation
2018-09-08 18:23:23 +00:00
[core] extend (data_string *) to store header id (optional addition to (data_string *), used by http_header.[ch]) extend (data_string *) instead of creating another data_* TYPE_* (new data type would probably have (data_string *) as base class) (might revisit choice in the future) HTTP_HEADER_UNSPECIFIED has been removed. It was used in select locations as an optimization to avoid looking up enum header_header_e before checking the array, but the ordering in the array now relies on having the id. Having the id allows for a quick check if a common header is present or not in the htags bitmask, before checking the array, and allows for integer comparison in the log(n) search of the array, instead of strncasecmp(). With HTTP_HEADER_UNSPECIFIED removed, add optimization to set bit in htags for HTTP_HEADER_OTHER when an "other" header is added, but do not clear the bit, as there might be addtl "other" headers
2020-09-11 21:25:43 +00:00
__attribute_hot__
buffer * array_get_buf_ptr_ext(array * const a, const int ext, const char * const k, const uint32_t klen) {
int32_t ipos = array_get_index_ext(a, ext, k, klen);
if (ipos >= 0) return &((data_string *)a->sorted[ipos])->value;
data_string * const ds = array_insert_string_at_pos(a, (uint32_t)(-ipos-1));
ds->ext = ext;
buffer_copy_string_len(&ds->key, k, klen);
buffer_clear(&ds->value);
return &ds->value;
}
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
int * array_get_int_ptr(array * const a, const char * const k, const uint32_t klen) {
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
int32_t ipos = array_get_index(a, k, klen);
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
if (ipos >= 0) return &((data_integer *)a->sorted[ipos])->value;
Add "lighty.req_env" table to mod_magnet for setting/getting environment values for cgi (fixes #1967, thx presbrey) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2515 152afb58-edef-0310-8abb-c4023f1b3aa9
2009-06-10 13:08:15 +00:00
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
data_integer * const di =array_insert_integer_at_pos(a,(uint32_t)(-ipos-1));
[core] inline buffer as part of DATA_UNSET key (instead of key being (buffer *))
2019-10-13 07:37:59 +00:00
buffer_copy_string_len(&di->key, k, klen);
[core] short-circuit path to clear request.headers short-circuit path to clear con->request.headers if entire size of all request headers is <= BUFFER_MAX_REUSE_SIZE clear (reset) data_string key and value upon reuse
2019-10-06 19:55:53 +00:00
di->value = 0;
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
return &di->value;
Add "lighty.req_env" table to mod_magnet for setting/getting environment values for cgi (fixes #1967, thx presbrey) git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@2515 152afb58-edef-0310-8abb-c4023f1b3aa9
2009-06-10 13:08:15 +00:00
}
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
buffer * array_get_buf_ptr(array * const a, const char * const k, const uint32_t klen) {
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
int32_t ipos = array_get_index(a, k, klen);
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
if (ipos >= 0) return &((data_string *)a->sorted[ipos])->value;
[core] array_get_int_ptr()
2018-09-23 00:10:51 +00:00
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
data_string * const ds = array_insert_string_at_pos(a, (uint32_t)(-ipos-1));
[core] inline buffer as part of DATA_UNSET key (instead of key being (buffer *))
2019-10-13 07:37:59 +00:00
buffer_copy_string_len(&ds->key, k, klen);
[core] inline buffer as part of data_string value (instead of value being (buffer *))
2019-10-13 08:59:57 +00:00
buffer_clear(&ds->value);
return &ds->value;
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
}
[core] array_get_int_ptr()
2018-09-23 00:10:51 +00:00
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
void array_insert_value(array * const a, const char * const v, const uint32_t vlen) {
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
data_string * const ds = array_insert_string_at_pos(a, a->used);
[core] inline buffer as part of DATA_UNSET key (instead of key being (buffer *))
2019-10-13 07:37:59 +00:00
buffer_clear(&ds->key);
[core] inline buffer as part of data_string value (instead of value being (buffer *))
2019-10-13 08:59:57 +00:00
buffer_copy_string_len(&ds->value, v, vlen);
[core] array_get_int_ptr()
2018-09-23 00:10:51 +00:00
}
[core] improve array API to prevent theoretical memory leaks - refactor insert into array_find_or_insert; if the element already exists the caller must resolve the conflict manually: - array_replace frees the old element - array_insert_unique calls "insert_dup" both have no return value anymore - fix usages of array_replace; they now don't need to delete the old entry anymore; usage in configparser was probably broken, as it possibly deleted the old element before calling array_replace This should fix a lot of the issues reported in "Fortify Open Review Project - lighttpd 1.4.39" (usually hitting the array limit): when the array size limit was hit "new" entries leaked instead of getting added. On 32-bit INT_MAX entries cannot actually be reached (each entry requires at least 48 bytes, leading to a total of 96GB memory). On 64-bit INT_MAX entries would require 224GB memory, so it would be theoretically possible. But it would need 2^27 reallocations of two C-arrays of up to 16GB size. From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3098 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:26:57 +00:00
/* if entry already exists return pointer to existing entry, otherwise insert entry and return NULL */
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
__attribute_cold__
static data_unset **array_find_or_insert(array * const a, data_unset * const entry) {
force_assert(NULL != entry);
/* push value onto end of array if there is no key */
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (buffer_is_unset(&entry->key)) {
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
array_insert_data_at_pos(a, entry, a->used);
return NULL;
}
- white space cleanup part 2 this time 1.4 ;) i hope it helps with merging stuff back to 1.5 git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@1371 152afb58-edef-0310-8abb-c4023f1b3aa9
2006-10-04 13:26:23 +00:00
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
/* try to find the entry */
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
const int32_t ipos = array_get_index(a, BUF_PTR_LEN(&entry->key));
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
if (ipos >= 0) return &a->sorted[ipos];
- white space cleanup part 2 this time 1.4 ;) i hope it helps with merging stuff back to 1.5 git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@1371 152afb58-edef-0310-8abb-c4023f1b3aa9
2006-10-04 13:26:23 +00:00
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
array_insert_data_at_pos(a, entry, (uint32_t)(-ipos - 1));
return NULL;
[core] improve array API to prevent theoretical memory leaks - refactor insert into array_find_or_insert; if the element already exists the caller must resolve the conflict manually: - array_replace frees the old element - array_insert_unique calls "insert_dup" both have no return value anymore - fix usages of array_replace; they now don't need to delete the old entry anymore; usage in configparser was probably broken, as it possibly deleted the old element before calling array_replace This should fix a lot of the issues reported in "Fortify Open Review Project - lighttpd 1.4.39" (usually hitting the array limit): when the array size limit was hit "new" entries leaked instead of getting added. On 32-bit INT_MAX entries cannot actually be reached (each entry requires at least 48 bytes, leading to a total of 96GB memory). On 64-bit INT_MAX entries would require 224GB memory, so it would be theoretically possible. But it would need 2^27 reallocations of two C-arrays of up to 16GB size. From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3098 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:26:57 +00:00
}
/* replace or insert data (free existing entry) */
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
void array_replace(array * const a, data_unset * const entry) {
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
if (NULL == array_find_or_insert(a, entry)) return;
[core] improve array API to prevent theoretical memory leaks - refactor insert into array_find_or_insert; if the element already exists the caller must resolve the conflict manually: - array_replace frees the old element - array_insert_unique calls "insert_dup" both have no return value anymore - fix usages of array_replace; they now don't need to delete the old entry anymore; usage in configparser was probably broken, as it possibly deleted the old element before calling array_replace This should fix a lot of the issues reported in "Fortify Open Review Project - lighttpd 1.4.39" (usually hitting the array limit): when the array size limit was hit "new" entries leaked instead of getting added. On 32-bit INT_MAX entries cannot actually be reached (each entry requires at least 48 bytes, leading to a total of 96GB memory). On 64-bit INT_MAX entries would require 224GB memory, so it would be theoretically possible. But it would need 2^27 reallocations of two C-arrays of up to 16GB size. From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3098 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:26:57 +00:00
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
/* find the entry (array_find_or_insert() returned non-NULL) */
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
const int32_t ipos = array_get_index(a, BUF_PTR_LEN(&entry->key));
[core] array a->sorted[] as ptrs rather than pos While slightly more memory use in 64-bit (though same memory use as prior versions of lighttpd), avoids bouncing through second array when searching in sorted list. Most use of arrays in lighttpd is to build a list once, and elements are not removed from the list.
2019-10-16 02:45:30 +00:00
force_assert(ipos >= 0);
data_unset *old = a->sorted[ipos];
force_assert(old != entry);
a->sorted[ipos] = entry;
uint32_t i = 0;
while (i < a->used && a->data[i] != old) ++i;
force_assert(i != a->used);
a->data[i] = entry;
old->fn->free(old);
[core] improve array API to prevent theoretical memory leaks - refactor insert into array_find_or_insert; if the element already exists the caller must resolve the conflict manually: - array_replace frees the old element - array_insert_unique calls "insert_dup" both have no return value anymore - fix usages of array_replace; they now don't need to delete the old entry anymore; usage in configparser was probably broken, as it possibly deleted the old element before calling array_replace This should fix a lot of the issues reported in "Fortify Open Review Project - lighttpd 1.4.39" (usually hitting the array limit): when the array size limit was hit "new" entries leaked instead of getting added. On 32-bit INT_MAX entries cannot actually be reached (each entry requires at least 48 bytes, leading to a total of 96GB memory). On 64-bit INT_MAX entries would require 224GB memory, so it would be theoretically possible. But it would need 2^27 reallocations of two C-arrays of up to 16GB size. From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3098 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:26:57 +00:00
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
void array_insert_unique(array * const a, data_unset * const entry) {
[core] improve array API to prevent theoretical memory leaks - refactor insert into array_find_or_insert; if the element already exists the caller must resolve the conflict manually: - array_replace frees the old element - array_insert_unique calls "insert_dup" both have no return value anymore - fix usages of array_replace; they now don't need to delete the old entry anymore; usage in configparser was probably broken, as it possibly deleted the old element before calling array_replace This should fix a lot of the issues reported in "Fortify Open Review Project - lighttpd 1.4.39" (usually hitting the array limit): when the array size limit was hit "new" entries leaked instead of getting added. On 32-bit INT_MAX entries cannot actually be reached (each entry requires at least 48 bytes, leading to a total of 96GB memory). On 64-bit INT_MAX entries would require 224GB memory, so it would be theoretically possible. But it would need 2^27 reallocations of two C-arrays of up to 16GB size. From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3098 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:26:57 +00:00
data_unset **old;
if (NULL != (old = array_find_or_insert(a, entry))) {
[core] make insert_dup an optional array method make insert_dup an optional array method in data_methods (currently used only for merging strings of type data_string)
2021-05-23 00:34:58 +00:00
if (entry->fn->insert_dup) {
force_assert((*old)->type == entry->type);
entry->fn->insert_dup(*old, entry);
}
entry->fn->free(entry);
[core] improve array API to prevent theoretical memory leaks - refactor insert into array_find_or_insert; if the element already exists the caller must resolve the conflict manually: - array_replace frees the old element - array_insert_unique calls "insert_dup" both have no return value anymore - fix usages of array_replace; they now don't need to delete the old entry anymore; usage in configparser was probably broken, as it possibly deleted the old element before calling array_replace This should fix a lot of the issues reported in "Fortify Open Review Project - lighttpd 1.4.39" (usually hitting the array limit): when the array size limit was hit "new" entries leaked instead of getting added. On 32-bit INT_MAX entries cannot actually be reached (each entry requires at least 48 bytes, leading to a total of 96GB memory). On 64-bit INT_MAX entries would require 224GB memory, so it would be theoretically possible. But it would need 2^27 reallocations of two C-arrays of up to 16GB size. From: Stefan Bühler <stbuehler@web.de> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3098 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-15 18:26:57 +00:00
}
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
int array_is_vlist(const array * const a) {
for (uint32_t i = 0; i < a->used; ++i) {
[config] more specific checks for array lists More specific checks on contents of array lists. Each module using lists now does better checking on the types of values in the list (strings, integers, arrays/lists) This helps prevent misconfiguration of things like cgi.assign, fastcgi.server, and scgi.server, where source code might be served as static files if parenthesis are misplaced. x-ref: https://redmine.lighttpd.net/boards/2/topics/6571
2017-03-05 20:39:45 +00:00
data_unset *du = a->data[i];
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (!buffer_is_unset(&du->key) || du->type != TYPE_STRING) return 0;
[config] more specific checks for array lists More specific checks on contents of array lists. Each module using lists now does better checking on the types of values in the list (strings, integers, arrays/lists) This helps prevent misconfiguration of things like cgi.assign, fastcgi.server, and scgi.server, where source code might be served as static files if parenthesis are misplaced. x-ref: https://redmine.lighttpd.net/boards/2/topics/6571
2017-03-05 20:39:45 +00:00
}
return 1;
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
int array_is_kvany(const array * const a) {
for (uint32_t i = 0; i < a->used; ++i) {
[config] more specific checks for array lists More specific checks on contents of array lists. Each module using lists now does better checking on the types of values in the list (strings, integers, arrays/lists) This helps prevent misconfiguration of things like cgi.assign, fastcgi.server, and scgi.server, where source code might be served as static files if parenthesis are misplaced. x-ref: https://redmine.lighttpd.net/boards/2/topics/6571
2017-03-05 20:39:45 +00:00
data_unset *du = a->data[i];
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (buffer_is_unset(&du->key)) return 0;
[config] more specific checks for array lists More specific checks on contents of array lists. Each module using lists now does better checking on the types of values in the list (strings, integers, arrays/lists) This helps prevent misconfiguration of things like cgi.assign, fastcgi.server, and scgi.server, where source code might be served as static files if parenthesis are misplaced. x-ref: https://redmine.lighttpd.net/boards/2/topics/6571
2017-03-05 20:39:45 +00:00
}
return 1;
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
int array_is_kvarray(const array * const a) {
for (uint32_t i = 0; i < a->used; ++i) {
[config] more specific checks for array lists More specific checks on contents of array lists. Each module using lists now does better checking on the types of values in the list (strings, integers, arrays/lists) This helps prevent misconfiguration of things like cgi.assign, fastcgi.server, and scgi.server, where source code might be served as static files if parenthesis are misplaced. x-ref: https://redmine.lighttpd.net/boards/2/topics/6571
2017-03-05 20:39:45 +00:00
data_unset *du = a->data[i];
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (buffer_is_unset(&du->key) || du->type != TYPE_ARRAY) return 0;
[config] more specific checks for array lists More specific checks on contents of array lists. Each module using lists now does better checking on the types of values in the list (strings, integers, arrays/lists) This helps prevent misconfiguration of things like cgi.assign, fastcgi.server, and scgi.server, where source code might be served as static files if parenthesis are misplaced. x-ref: https://redmine.lighttpd.net/boards/2/topics/6571
2017-03-05 20:39:45 +00:00
}
return 1;
}
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
int array_is_kvstring(const array * const a) {
for (uint32_t i = 0; i < a->used; ++i) {
[config] more specific checks for array lists More specific checks on contents of array lists. Each module using lists now does better checking on the types of values in the list (strings, integers, arrays/lists) This helps prevent misconfiguration of things like cgi.assign, fastcgi.server, and scgi.server, where source code might be served as static files if parenthesis are misplaced. x-ref: https://redmine.lighttpd.net/boards/2/topics/6571
2017-03-05 20:39:45 +00:00
data_unset *du = a->data[i];
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
if (buffer_is_unset(&du->key) || du->type != TYPE_STRING) return 0;
[config] more specific checks for array lists More specific checks on contents of array lists. Each module using lists now does better checking on the types of values in the list (strings, integers, arrays/lists) This helps prevent misconfiguration of things like cgi.assign, fastcgi.server, and scgi.server, where source code might be served as static files if parenthesis are misplaced. x-ref: https://redmine.lighttpd.net/boards/2/topics/6571
2017-03-05 20:39:45 +00:00
}
return 1;
}
[core] code reuse array_match_*() routines
2018-09-16 17:27:18 +00:00
/* array_match_*() routines follow very similar pattern, but operate on slightly
* different data: array key/value, prefix/suffix match, case-insensitive or not
* While these could be combined into fewer routines with flags to modify the
* behavior, the interface distinctions are useful to add clarity to the code,
* and the specialized routines run slightly faster */
data_unset *
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
array_match_key_prefix_klen (const array * const a, const char * const s, const uint32_t slen)
[core] code reuse array_match_*() routines
2018-09-16 17:27:18 +00:00
{
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
for (uint32_t i = 0; i < a->used; ++i) {
[core] inline buffer as part of DATA_UNSET key (instead of key being (buffer *))
2019-10-13 07:37:59 +00:00
const buffer * const key = &a->data[i]->key;
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
const uint32_t klen = buffer_clen(key);
[core] code reuse array_match_*() routines
2018-09-16 17:27:18 +00:00
if (klen <= slen && 0 == memcmp(s, key->ptr, klen))
return a->data[i];
}
return NULL;
}
data_unset *
[core] array.[ch] using uint32_t instead of size_t
2020-09-11 18:22:34 +00:00
array_match_key_prefix_nc_klen (const array * const a, const char * const s, const uint32_t slen)
[core] code reuse array_match_*() routines
2018-09-16 17:27:18 +00:00
{
[core] perf: array.c performance enhancements mark array_get_index() as hot, rewrite to be pure and return sorted pos mark routines as pure, as appropriate mark routines as cold if used only at startup for config processing mark params const, as appropriate array_get_buf_ptr() for modifiable value buffer after insert into array uint32_t used and size members instead of size_t remove a->unique_ndx member; simply add to end of array for value lists remove du->is_index_key member; simply check buffer_is_empty(du->key) array_insert_key_value() used to be a hint that lookup could be skipped, but the state from array_get_index() is now saved and reused internally, so the distinction is no longer needed. Use array_set_key_value().
2019-10-02 05:54:15 +00:00
for (uint32_t i = 0; i < a->used; ++i) {
[core] inline buffer as part of DATA_UNSET key (instead of key being (buffer *))
2019-10-13 07:37:59 +00:00
const buffer * const key = &a->data[i]->key;
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
const uint32_t klen = buffer_clen(key);
[core] use buffer_eq_icase_ssn func specialized buffer_eq_icase_ssn func replace strncasecmp() in cases where string lengths are known to be at least as large as the len being compared case-insensitively
2019-06-06 05:17:43 +00:00
if (klen <= slen && buffer_eq_icase_ssn(s, key->ptr, klen))
[core] code reuse array_match_*() routines
2018-09-16 17:27:18 +00:00
return a->data[i];
}
return NULL;
}
data_unset *
array_match_key_prefix (const array * const a, const buffer * const b)
{
quiet clang analyzer scan-build warnings (expansion of buffer_string_lenth() inline function and CONST_BUF_LEN() macro, which always check for NULL, appears to cause the analyzer to believe that a pointer might be NULL in cases where it otherwise can not be NULL) x-ref: http://clang-analyzer.llvm.org/faq.html
2020-07-08 22:01:52 +00:00
#ifdef __clang_analyzer__
force_assert(b);
#endif
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
2021-06-09 02:57:36 +00:00
return array_match_key_prefix_klen(a, BUF_PTR_LEN(b));
[core] code reuse array_match_*() routines
2018-09-16 17:27:18 +00:00
}