int trace_print_message(char* str, size_t size,
const void* msg, size_t msg_size, int cpu, u64 ts, void* user_data)
{
int result, result_total = 0;
const struct kedr_trace_message* msg_real =
(const struct kedr_trace_message*)msg;
// ts is time in nanoseconds since system starts
u32 sec, ms;
sec = div_u64_rem(ts, 1000000000, &ms);
ms /= 1000;
(void)user_data;
#define update_str(str, size, result) \
if(size <= result) { str += size; size = 0; } \
else{ str += result; size -= result; }
result = snprintf(str, size, "%s-%d\t[%.03d]\t%lu.%.06u:\t",
msg_real->command, msg_real->pid,
cpu, (unsigned long)sec, (unsigned)ms);
result_total += result;
update_str(str, size, result);
result = msg_real->pp(str,
size, msg_real->data);
result_total += result;
update_str(str, size, result);
result = snprintf(str, size, "\n");
result_total += result;
#undef update_str
return result_total;
}
/*!
* \brief Update existing contact in memory with new values
* \param _c contact
* \param _ci contact informations
* \return 0 on success, -1 on failure
*/
int mem_update_ucontact(ucontact_t* _c, ucontact_info_t* _ci) {
#define update_str(_old,_new) \
do{\
if ((_old)->len < (_new)->len) { \
ptr = (char*)shm_malloc((_new)->len); \
if (ptr == 0) { \
LM_ERR("no more shm memory\n"); \
return -1; \
}\
memcpy(ptr, (_new)->s, (_new)->len);\
if ((_old)->s) shm_free((_old)->s);\
(_old)->s = ptr;\
} else {\
memcpy((_old)->s, (_new)->s, (_new)->len);\
}\
(_old)->len = (_new)->len;\
} while(0)
char* ptr;
/* No need to update Callid as it is constant
* per ucontact (set at insert time) -bogdan */
update_str(&_c->user_agent, _ci->user_agent);
if (_ci->received.s && _ci->received.len) {
update_str(&_c->received, &_ci->received);
} else {
if (_c->received.s) shm_free(_c->received.s);
_c->received.s = 0;
_c->received.len = 0;
}
if (_ci->path) {
update_str(&_c->path, _ci->path);
} else {
if (_c->path.s) shm_free(_c->path.s);
_c->path.s = 0;
_c->path.len = 0;
}
LM_DBG("Setting contact expires to %d which is in %d seconds time\n", (unsigned int) _ci->expires, (unsigned int) (_ci->expires - time(NULL)));
_c->sock = _ci->sock;
_c->expires = _ci->expires;
_c->q = _ci->q;
_c->cseq = _ci->cseq;
_c->methods = _ci->methods;
_c->last_modified = _ci->last_modified;
_c->flags = _ci->flags;
_c->cflags = _ci->cflags;
return 0;
}
/*!
* \brief Update existing contact in memory with new values
* \param _c contact
* \param _ci contact informations
* \return 0 on success, -1 on failure
*/
int mem_update_ucontact(ucontact_t* _c, ucontact_info_t* _ci)
{
#define update_str(_old,_new) \
do{\
if ((_old)->len < (_new)->len) { \
ptr = (char*)shm_malloc((_new)->len); \
if (ptr == 0) { \
LM_ERR("no more shm memory\n"); \
return -1; \
}\
memcpy(ptr, (_new)->s, (_new)->len);\
if ((_old)->s) shm_free((_old)->s);\
(_old)->s = ptr;\
} else {\
memcpy((_old)->s, (_new)->s, (_new)->len);\
}\
(_old)->len = (_new)->len;\
} while(0)
char* ptr;
/* Update gruu */
if(_ci->instance.s!=NULL && _ci->instance.len>0) {
update_str (& _c->instance, &_ci->instance);
}
/* Update contact */
if(_ci->c!=NULL && _ci->c->s!=NULL && _ci->c->len>0) {
update_str( &_c->c, _ci->c);
}
/* Update callid */
if(_ci->callid!=NULL && _ci->callid->s!=NULL && _ci->callid->len>0) {
update_str( &_c->callid, _ci->callid);
}
/* No need to update Callid as it is constant
* per ucontact (set at insert time) -bogdan */
update_str( &_c->user_agent, _ci->user_agent);
if (_ci->received.s && _ci->received.len) {
update_str( &_c->received, &_ci->received);
} else {
if (_c->received.s) shm_free(_c->received.s);
_c->received.s = 0;
_c->received.len = 0;
}
if (_ci->path) {
update_str( &_c->path, _ci->path);
} else {
if (_c->path.s) shm_free(_c->path.s);
_c->path.s = 0;
_c->path.len = 0;
}
_c->sock = _ci->sock;
_c->expires = _ci->expires;
_c->q = _ci->q;
_c->cseq = _ci->cseq;
_c->methods = _ci->methods;
_c->last_modified = _ci->last_modified;
_c->flags = _ci->flags;
_c->cflags = _ci->cflags;
return 0;
}
int main(int argc, char* argv[]) {
int which = 0;
data_t *heap_data = (data_t *)malloc(sizeof(data_t));
if (argc >= 2) {
which = atoi(argv[1]);
}
init(&global_data);
init(heap_data);
switch(which) {
case 0:
cilk_spawn increment_i(&global_data); // write, read race
mult_double(&global_data);
cilk_sync;
assert(__cilksan_error_count() == 3);
break;
case 1:
cilk_spawn mult_double(&global_data);
increment_i(&global_data); // write, read race
cilk_sync;
assert(__cilksan_error_count() == 3);
break;
case 2:
cilk_spawn mult_double(&global_data);
update_str(&global_data, 3, 8); // read, write race
cilk_sync;
assert(__cilksan_error_count() == 2);
break;
case 3:
cilk_spawn increment_i(&global_data); // write, read race
read_double(&global_data);
cilk_sync;
assert(__cilksan_error_count() == 1);
break;
case 4:
cilk_spawn read_double(&global_data);
increment_i(&global_data); // read, write race
cilk_sync;
assert(__cilksan_error_count() == 1);
break;
case 5:
cilk_spawn read_double(&global_data);
update_str(&global_data, 3, 8); // read, write race
cilk_sync;
assert(__cilksan_error_count() == 1);
break;
case 6:
cilk_spawn read_str(&global_data, 2, 4);
update_str(&global_data, 3, 8); // read, write race
cilk_sync;
assert(__cilksan_error_count() == 1);
break;
case 7:
cilk_spawn increment_i(heap_data); // write, read race
mult_double(heap_data);
cilk_sync;
assert(__cilksan_error_count() == 3);
break;
case 8:
cilk_spawn mult_double(heap_data);
increment_i(heap_data); // write, read race
cilk_sync;
assert(__cilksan_error_count() == 3);
break;
case 9:
cilk_spawn mult_double(heap_data);
update_str(heap_data, 3, 8); // write, write race
cilk_sync;
assert(__cilksan_error_count() == 2);
break;
case 10:
cilk_spawn increment_i(heap_data); // write, read race
read_double(heap_data);
cilk_sync;
assert(__cilksan_error_count() == 1);
break;
case 11:
cilk_spawn read_double(heap_data);
increment_i(heap_data); // read, write race
cilk_sync;
// to be sure that compiler doesn't optimize it away.
global_int = heap_data->i;
assert(__cilksan_error_count() == 1);
break;
case 12:
cilk_spawn read_double(heap_data);
update_str(heap_data, 3, 8); // read, write race
cilk_sync;
assert(__cilksan_error_count() == 1);
break;
case 13:
cilk_spawn update_str(heap_data, 8, 11);
read_str(heap_data, 10, 12); // write, read race
cilk_sync;
assert(__cilksan_error_count() == 1);
break;
case 14:
cilk_spawn update_str(&global_data, 8, 12); // no race
mult_double(&global_data);
cilk_sync;
assert(__cilksan_error_count() == 0);
break;
case 15:
cilk_spawn update_str(&global_data, 4, 12); // no race
read_i(&global_data);
cilk_sync;
assert(__cilksan_error_count() == 0);
break;
case 16:
cilk_spawn update_str(heap_data, 8, 12); // no race
mult_double(heap_data);
cilk_sync;
assert(__cilksan_error_count() == 0);
break;
case 17:
cilk_spawn update_str(heap_data, 4, 12); // no race
read_i(heap_data);
cilk_sync;
assert(__cilksan_error_count() == 0);
break;
case 18:
cilk_spawn update_str(heap_data, 3, 5); // no race
update_str(heap_data, 5, 8);
cilk_sync;
assert(__cilksan_error_count() == 0);
break;
case 19:
read_and_write(&global_data); // read write race, but just 1
read_and_write(heap_data);
cilk_sync;
assert(__cilksan_error_count() == 1);
break;
}
cilk_sync;
free(heap_data);
return 0;
}
