static ERR_VALUE _init_lookasides(const uint32_t KmerSize, PUTILS_LOOKASIDE *VA, PUTILS_LOOKASIDE *EA)
{
ERR_VALUE ret = ERR_SUCCESS;
int threadIndex = omp_get_thread_num();
if (_vertexLAs[threadIndex] == NULL) {
ret = utils_malloc(sizeof(UTILS_LOOKASIDE), _vertexLAs + threadIndex);
if (ret == ERR_SUCCESS) {
ret = utils_lookaside_init(_vertexLAs[threadIndex], sizeof(KMER_VERTEX) + KmerSize, 3000);
if (ret != ERR_SUCCESS) {
utils_free(_vertexLAs[threadIndex]);
_vertexLAs[threadIndex] = NULL;
}
}
}
if (ret == ERR_SUCCESS) {
*VA = _vertexLAs[threadIndex];
if (_edgeLAs[threadIndex] == NULL) {
ret = utils_malloc(sizeof(UTILS_LOOKASIDE), _edgeLAs + threadIndex);
if (ret == ERR_SUCCESS) {
ret = utils_lookaside_init(_edgeLAs[threadIndex], sizeof(KMER_EDGE), 5000);
if (ret != ERR_SUCCESS) {
utils_free(_edgeLAs[threadIndex]);
_edgeLAs[threadIndex] = NULL;
}
}
}
if (ret == ERR_SUCCESS)
*EA = _edgeLAs[threadIndex];
}
return ret;
}
void
string_list_duplicate_items (StringList *list,
const StringList *duplicate_from_list)
{
const StringListItem *item;
StringListItem *last_duplicated_item = NULL;
StringListItem **link;
assert (list);
assert (list->first == NULL);
assert (duplicate_from_list);
link = &list->first;
for (item = duplicate_from_list->first; item; item = item->next) {
last_duplicated_item = utils_malloc (sizeof (StringListItem));
last_duplicated_item->text = utils_duplicate_string (item->text);
*link = last_duplicated_item;
link = &last_duplicated_item->next;
}
*link = NULL;
list->last = last_duplicated_item;
}
/**
* MPI prijem zasobniku a spojeni s lokalnim zasobnikem.
*/
void mpi_recv_stack(const int src) {
assert(t);
assert(s);
MPI_Status mpi_status;
unsigned int l;
char *b = NULL;
MPI_Recv(&l, 1, MPI_UNSIGNED, src, MSG_STACK,
MPI_COMM_WORLD, &mpi_status);
srpdebug("mpi", node, "prijeti zasobnik <l=%db, src=%d>",
l, mpi_status.MPI_SOURCE);
// naalokuju buffer a zahajim blokujici cekani na MSG_STACK_DATA
srpdebug("mpi", node, "cekani na zpravu <delka=%db>", l);
MPI_Probe(src, MSG_STACK_DATA, MPI_COMM_WORLD,
&mpi_status);
b = (char *)utils_malloc(l * sizeof(char));
MPI_Recv(b, l, MPI_PACKED, src, MSG_STACK_DATA,
MPI_COMM_WORLD, &mpi_status);
stack_t *sn = stack_mpiunpack(b, t, l);
free(b);
srpdebug("mpi", node, "prijeti zasobnik <s=%d>", sn->s);
// sloucit zasobniky
stack_merge(s, sn);
}
/**
* MPI vymena zadani pomoci broadcastu. Uzly se nejdrive dozvi potrebnou
* velikost bufferu a posleze obdrzi strukturu ukolu.
*/
int mpi_bcast_task() {
int l; // delka bufferu zpravy
char *b = NULL; // buffer zpravy
unsigned int n,k,q;
// serializovat ulohu
if(node == 0) {
assert(t);
b = task_mpipack(t, &l, 0);
}
// distribuovat velikost b
MPI_Bcast(&l, 1, MPI_INT, 0, MPI_COMM_WORLD);
srpdebug("mpi", node, "broadcast velikost zpravy <l=%d>", l);
// pripravit buffer na ostatnich uzlech
if(node > 0)
b = (char *)utils_malloc(l * sizeof(char));
MPI_Bcast(b, l, MPI_PACKED, 0, MPI_COMM_WORLD);
srpdebug("mpi", node, "broadcast zadani ulohy");
// de-serializovat ulohu
if(node > 0) {
assert(b);
t = task_mpiunpack(b, l, 0);
assert(t);
srpdebug("mpi", node, "prijeti zadani ulohy <n=%d, k=%d, q=%d>",
t->n, t->k, t->q);
}
free(b);
return 1;
}
/* Allocate a copy of given buffer (pointer + length) on heap. */
void *
utils_duplicate_buffer (const void *buffer, int length)
{
char *buffer_copy = utils_malloc (length);
memcpy (buffer_copy, buffer, length);
return buffer_copy;
}
/* Convenience function. Allocate memory chunk and initialize all its
* bytes to zero.
*/
void *
utils_malloc0 (size_t size)
{
void *pointer = utils_malloc (size);
memset (pointer, 0, size);
return pointer;
}
void *
string_list_new_derived (int item_size, StringListItemDispose item_dispose)
{
void *list = utils_malloc (sizeof (StringList));
string_list_init_derived (list, item_size, item_dispose);
return list;
}
/* Similar to utils_duplicate_buffer(), but also appends a zero byte
* to the copy, thus making it a valid ASCIIZ string.
*/
char *
utils_duplicate_as_string (const char *buffer, int length)
{
char *string = utils_malloc (length + 1);
memcpy (string, buffer, length);
string[length] = 0;
return string;
}
TimeControl *
time_control_new (int main_time, int overtime_length, int moves_per_overtime)
{
TimeControl *time_control = utils_malloc (sizeof (TimeControl));
time_control_init (time_control,
main_time, overtime_length, moves_per_overtime);
return time_control;
}
size_t
blacklist_load(Blacklist *blacklist, const char *filename)
{
FILE *fp;
size_t count = 0;
assert(blacklist != NULL);
assert(filename != NULL);
DEBUGF("blacklist", "Loading file: %s", filename);
if((fp = fopen(filename, "r")))
{
char *pattern = (char *)utils_malloc(64);
size_t bytes = 64;
ssize_t result;
result = getline(&pattern, &bytes, fp);
while(result > 0 && count != SIZE_MAX)
{
size_t len = utils_trim(pattern);
if(len && *pattern != '#')
{
size_t pathc = blacklist_glob(blacklist, pattern);
if(SIZE_MAX - count >= pathc)
{
count += pathc;
}
else
{
WARNING("blacklist", "Integer overflow.");
fprintf(stderr, _("Couldn't allocate memory.\n"));
count = SIZE_MAX;
}
}
result = getline(&pattern, &bytes, fp);
}
free(pattern);
fclose(fp);
}
else
{
DEBUGF("blacklist", "File not found: %s", filename);
}
return count;
}
inline static void
push_condition_stack (const PredefinedCondition *condition, int is_negated)
{
ConditionStackEntry *entry = utils_malloc (sizeof (ConditionStackEntry));
entry->condition = condition;
entry->is_true = (condition->value != 0) ^ (is_negated != 0);
entry->is_in_else_clause = 0;
entry->next = condition_stack;
condition_stack = entry;
}
/* Allocate a copy of given string on heap. Analogous to strdup(),
* which does not belong to most accepted standards (neither ASCII C,
* nor POSIX).
*/
char *
utils_duplicate_string (const char *string)
{
if (string) {
int length = strlen (string);
char *new_string = utils_malloc (length + 1);
memcpy (new_string, string, length + 1);
return new_string;
}
return NULL;
}
/* Same as utils_cprintf(), but `arguments' are passed as
* `va_list'.
*/
char *
utils_vcprintf (const char *format_string, va_list arguments)
{
char *string;
int num_bytes_required;
va_list arguments_copy;
QUARRY_VA_COPY (arguments_copy, arguments);
num_bytes_required = (utils_vncprintf (NULL, 0, format_string,
arguments_copy)
+ 1);
va_end (arguments_copy);
string = utils_malloc (num_bytes_required);
utils_vncprintf (string, num_bytes_required, format_string, arguments);
return string;
}
/* Call utils_ncprintf() with given `format_string' and arguments and
* return its result in a dynamically allocated buffer. This function
* ignores locales and should be used in cases when arguments are to
* be formatted according to C locale.
*/
char *
utils_cprintf (const char *format_string, ...)
{
char *string;
int num_bytes_required;
va_list arguments;
va_start (arguments, format_string);
num_bytes_required = utils_vncprintf (NULL, 0, format_string, arguments) + 1;
va_end (arguments);
string = utils_malloc (num_bytes_required);
va_start (arguments, format_string);
utils_vncprintf (string, num_bytes_required, format_string, arguments);
va_end (arguments);
return string;
}
static const char *_sam_read_string_field(const char *Start, char **String, size_t *Length)
{
char *tmpString = NULL;
const char *end = NULL;
size_t len = 0;
end = _sam_read_field(Start);
len = (end - Start);
if (len > 0) {
if (utils_malloc((len + 1)*sizeof(char), &tmpString) == ERR_SUCCESS) {
memcpy(tmpString, Start, len*sizeof(char));
tmpString[len] = '\0';
if (String != NULL) {
*String = tmpString;
*Length = len;
} else utils_free(tmpString);
} else end = NULL;
} else end = NULL;
return end;
}
char *
string_list_implode (const void *abstract_list, const char *separator)
{
const StringList *list = (const StringList *) abstract_list;
char *result = NULL;
assert (list);
assert (separator);
if (list->first) {
const StringListItem *item;
int separator_length = strlen (separator);
int result_length;
char *scan;
for (result_length = 1, item = list->first; item; item = item->next)
result_length += strlen (item->text) + separator_length;
result = utils_malloc (result_length);
for (scan = result, item = list->first; item; item = item->next) {
int item_text_length = strlen (item->text);
memcpy (scan, item->text, item_text_length);
scan += item_text_length;
if (item->next) {
memcpy (scan, separator, separator_length);
scan += separator_length;
}
}
*scan = 0;
}
return result;
}
