int32_t process_test_message(struct mile_message_header* msg_head,
struct data_buffer* rbuf, struct data_buffer* sbuf) {
int32_t result_code = MILE_RETURN_SUCCESS;
MEM_POOL_PTR mem_pool;
switch (msg_head->message_type) {
case MT_TEST_REQ_ECHO: // echo message for testing.
{
mem_pool = mem_pool_init(MB_SIZE);
const char *str = read_cstring(rbuf, mem_pool);
log_debug("get echo message [%s]", str);
write_int32(0, sbuf);
write_int8(msg_head->version_major, sbuf);
write_int8(msg_head->version_minor, sbuf);
write_int16(MT_TEST_RES_ECHO, sbuf);
write_int32(msg_head->message_id, sbuf);
write_int32(strlen(str), sbuf);
write_bytes((uint8_t *) str, strlen(str), sbuf);
fill_int32(sbuf->data_len, sbuf, 0);
result_code = MILE_RETURN_SUCCESS;
mem_pool_destroy(mem_pool);
}
break;
default:
result_code = -1;
break;
}
return result_code;
}
int
bson_encoder_append_int(bson_encoder_t encoder, const char *name, int64_t value)
{
bool result;
CODER_CHECK(encoder);
/* use the smallest encoding that will hold the value */
if (value == (int32_t)value) {
debug("encoding %lld as int32", value);
result = write_int8(encoder, BSON_INT32) ||
write_name(encoder, name) ||
write_int32(encoder, value);
} else {
debug("encoding %lld as int64", value);
result = write_int8(encoder, BSON_INT64) ||
write_name(encoder, name) ||
write_int64(encoder, value);
}
if (result) {
CODER_KILL(encoder, "write error on BSON_INT");
}
return 0;
}
static void jl_serialize_module(ios_t *s, jl_module_t *m)
{
// set on every startup; don't save
jl_sym_t *jhsym = jl_symbol("JULIA_HOME");
writetag(s, jl_module_type);
jl_serialize_value(s, m->name);
jl_serialize_value(s, m->parent);
size_t i;
void **table = m->bindings.table;
for(i=1; i < m->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND &&
!(table[i-1] == jhsym && m == jl_core_module)) {
jl_binding_t *b = (jl_binding_t*)table[i];
jl_serialize_value(s, b->name);
jl_serialize_value(s, b->value);
jl_serialize_value(s, b->type);
jl_serialize_value(s, b->owner);
write_int8(s, b->constp);
write_int8(s, b->exportp);
}
}
jl_serialize_value(s, NULL);
if (m == jl_main_module) {
write_int32(s, 1);
jl_serialize_value(s, (jl_value_t*)jl_core_module);
}
else {
write_int32(s, m->imports.len);
for(i=0; i < m->imports.len; i++) {
jl_serialize_value(s, (jl_value_t*)m->imports.items[i]);
}
}
}
struct data_buffer* gen_set_load_threshold_packet(char* cmd,MEM_POOL* mem_pool)
{
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t) + sizeof(double);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_SET_LOAD_THRESHOLD, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
char *value_str = strtok(NULL, " ");
if (!value_str)
return NULL;
double value = atof(value_str);
write_bytes((uint8_t *)&value, sizeof(value), dbuf);
return dbuf;
}
struct data_buffer* gen_stat_packet(char* cmd,uint8_t* type,MEM_POOL* mem_pool)
{
char* table_name = NULL;
char* token = NULL;
uint32_t tblen;
if((table_name = strtok(NULL," ")) == NULL)
return NULL;
tblen = strlen(table_name);
if((token = strtok(NULL," ")) == NULL)
return NULL;
*type = atoi(token);
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = tblen + 5 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_STAT, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
//拼接协议包
write_int32(tblen,dbuf);
write_bytes((uint8_t*)table_name,tblen,dbuf);
write_int8(*type,dbuf);
return dbuf;
}
static void jl_serialize_module(ios_t *s, jl_module_t *m)
{
writetag(s, jl_module_type);
jl_serialize_value(s, m->name);
size_t i;
void **table = m->bindings.table;
for(i=1; i < m->bindings.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_binding_t *b = (jl_binding_t*)table[i];
jl_serialize_value(s, b->name);
jl_serialize_value(s, b->value);
jl_serialize_value(s, b->type);
write_int8(s, b->constp);
write_int8(s, b->exportp);
}
}
jl_serialize_value(s, NULL);
table = m->macros.table;
for(i=1; i < m->macros.size; i+=2) {
if (table[i] != HT_NOTFOUND) {
jl_serialize_value(s, table[i-1]);
jl_serialize_value(s, table[i]);
}
}
jl_serialize_value(s, NULL);
}
struct data_buffer* gen_ensure_index_packet(char* cmd,MEM_POOL* mem_pool)
{
char* table_name = NULL;
char* field_name = NULL;
uint32_t tblen;
uint32_t fdlen;
char* token;
enum index_key_alg index_type;
enum field_types data_type;
if((table_name = strtok(NULL," ")) == NULL)
return NULL;
if((field_name = strtok(NULL," ")) == NULL)
return NULL;
if((token = strtok(NULL," ")) == NULL)
return NULL;
index_type = (index_key_alg)atoi(token);
if(index_type > 0xff)
return NULL;
if((token = strtok(NULL," ")) == NULL)
return NULL;
data_type = (enum field_types)atoi(token);
if(data_type > 0xff)
return NULL;
tblen = strlen(table_name);
fdlen = strlen(field_name);
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = tblen + fdlen + 10 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_INDEX, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
//拼接协议包
write_int32(tblen,dbuf);
write_bytes((uint8_t*)table_name,tblen,dbuf);
write_int32(fdlen,dbuf);
write_bytes((uint8_t*)field_name,fdlen,dbuf);
write_int8(index_type,dbuf);
write_int8(data_type,dbuf);
return dbuf;
}
/* Writes an IFF chunk header, consisting of a four-byte type identifier,
followed by the 32-bit chunk size (including the chunk header) */
static bool chunk_begin(IOStream *ios, const char *type, size_t size)
{
assert(strlen(type) == 4);
return
write_int8(ios, type[0]) &&
write_int8(ios, type[1]) &&
write_int8(ios, type[2]) &&
write_int8(ios, type[3]) &&
write_int32(ios, (int)size);
}
bool SAS::Connection::connect_init()
{
int rc;
struct sockaddr_in addr;
LOG_STATUS("Attempting to connect to SAS %s", _sas_address.c_str());
if ((_sock = ::socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
LOG_ERROR("Failed to open SAS socket: %d (%s)\n", errno, ::strerror(errno));
return false;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(SAS_PORT);
addr.sin_addr.s_addr = inet_addr(_sas_address.c_str());
rc = ::connect(_sock, (struct sockaddr*)&addr, sizeof(addr));
if (rc != 0)
{
LOG_ERROR("Failed to connect to SAS %s:%d : %d %s\n", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno));
::close(_sock);
return false;
}
LOG_DEBUG("Connected SAS socket to %s:%d", _sas_address.c_str(), SAS_PORT);
// Send an init message to SAS.
std::string init;
std::string version("v0.1");
int init_len = INIT_HDR_SIZE + sizeof(uint8_t) + _system_name.length() + sizeof(uint32_t) + sizeof(uint8_t) + version.length();
init.reserve(init_len);
write_hdr(init, init_len, SAS_MSG_INIT);
write_int8(init, (uint8_t)_system_name.length());
write_data(init, _system_name.length(), _system_name.data());
int endianness = 1;
init.append((char*)&endianness, sizeof(int)); // Endianness must be written in machine order.
write_int8(init, version.length());
write_data(init, version.length(), version.data());
LOG_DEBUG("Sending SAS INIT message");
rc = ::send(_sock, init.data(), init.length(), 0);
if (rc < 0)
{
LOG_ERROR("SAS connection to %s:%d failed: %d %s", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno));
return false;
}
LOG_STATUS("Connected to SAS %s:%d", _sas_address.c_str(), SAS_PORT);
return true;
}
int bson_encoder_append_bool(bson_encoder_t encoder, const char *name, bool value)
{
CODER_CHECK(encoder);
if (write_int8(encoder, BSON_BOOL) ||
write_name(encoder, name) ||
write_int8(encoder, value ? 1 : 0)) {
CODER_KILL(encoder, "write error on BSON_BOOL");
}
return 0;
}
int
bson_encoder_append_binary(bson_encoder_t encoder, const char *name, bson_binary_subtype_t subtype, size_t size,
const void *data)
{
CODER_CHECK(encoder);
if (write_int8(encoder, BSON_BINDATA) ||
write_name(encoder, name) ||
write_int32(encoder, size) ||
write_int8(encoder, subtype) ||
write_x(encoder, data, size)) {
CODER_KILL(encoder, "write error on BSON_BINDATA");
}
return 0;
}
void *spice_marshaller_add_int8(SpiceMarshaller *m, int8_t v)
{
uint8_t *ptr;
ptr = spice_marshaller_reserve_space(m, sizeof(int8_t));
write_int8(ptr, v);
return (void *)ptr;
}
struct data_buffer* gen_load_packet(char* cmd,MEM_POOL* mem_pool)
{
char* table_name = NULL;
char* segment_dir = NULL;
char* token = NULL;
uint32_t tblen;
uint32_t dirlen;
uint16_t sid;
if((table_name = strtok(NULL," ")) == NULL)
return NULL;
tblen = strlen(table_name);
if((token = strtok(NULL," ")) == NULL)
return NULL;
sid = atoi(token);
if((segment_dir = strtok(NULL," ")) == NULL)
return NULL;
dirlen = strlen(segment_dir);
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = tblen + dirlen + 10 * sizeof(uint8_t) + MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_LOAD, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
//拼接协议包
write_int32(tblen,dbuf);
write_bytes((uint8_t*)table_name,tblen,dbuf);
write_int16(sid,dbuf);
write_int32(dirlen,dbuf);
write_bytes((uint8_t*)segment_dir,dirlen,dbuf);
return dbuf;
}
struct data_buffer* gen_get_load_threshold_packet(char* cmd,MEM_POOL* mem_pool)
{
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_GET_LOAD_THRESHOLD, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
return dbuf;
}
struct data_buffer* gen_checkpoint_packet(char* cmd,MEM_POOL* mem_pool)
{
struct data_buffer *dbuf = init_data_buffer();
size_t data_len = MESSAGE_HEAD_LEN + 2*sizeof(uint32_t);
databuf_resize(dbuf, data_len);
//写入数据长度
write_int32(data_len,dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_CP, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
return dbuf;
}
static int writer_int8(lua_State* L)
{
writer_t* writer = lua_touserdata(L, 1);
lua_Integer integer = luaL_checkinteger(L, 2);
if(integer < INT8_MIN|| integer > INT8_MAX)
luaL_error(L, "integer overflow");
write_int8(writer, (int8_t)integer);
return 0;
}
static bool write_FUN_chunk(IOStream *ios, size_t chunk_size)
{
if (!chunk_begin(ios, "FUN ", chunk_size))
return false;
Function *functions = (Function*)AR_data(&ar_functions);
size_t nfunction = AR_size(&ar_functions), n, i;
if (!write_int32(ios, (int)nfunction))
return false;
/* Write function headers */
for (n = 0; n < nfunction; ++n)
{
if (!write_int16(ios, 0) ||
!write_int8(ios, functions[n].nret) ||
!write_int8(ios, functions[n].nparam))
{
return false;
}
}
/* Write function instructions */
for (n = 0; n < nfunction; ++n)
{
Instruction *ins = functions[n].instrs;
for (i = 0; (int)i < functions[n].ninstr; ++i)
{
assert(ins[i].opcode == (ins[i].opcode&255));
assert(ins[i].argument >= -0x00800000 && ins[i].argument <= 0x007fffff);
if (!write_int8(ios, ins[i].opcode) ||
!write_int24(ios, ins[i].argument))
return false;
}
if (!write_int32(ios, 0))
return false;
}
return chunk_end(ios, chunk_size);
}
int key_value_write_lines(FILE *f, struct key_value_specification *kvs, void *base_address[])
{
struct key_value_specification *k;
int rc;
int errs = 0;
for (k = kvs; k->key; k++) {
switch (k->type) {
case KVS_STRING:
rc = write_string(f, k, base_address);
break;
case KVS_INT64:
rc = write_int64(f, k, base_address);
break;
case KVS_INT32:
rc = write_int32(f, k, base_address);
break;
case KVS_INT16:
rc = write_int16(f, k, base_address);
break;
case KVS_INT8:
rc = write_int8(f, k, base_address);
break;
case KVS_UINT64:
rc = write_uint64(f, k, base_address);
break;
case KVS_UINT32:
rc = write_uint32(f, k, base_address);
break;
case KVS_UINT16:
rc = write_uint16(f, k, base_address);
break;
case KVS_UINT8:
rc = write_uint8(f, k, base_address);
break;
case KVS_DOUBLE:
rc = write_double(f, k, base_address);
break;
case KVS_FLOAT:
rc = write_float(f, k, base_address);
break;
default:
fprintf(stderr, "%s:%d: unknown key type '%c' for key '%s'\n",
__func__, __LINE__, k->type, k->key);
rc = -1;
break;
}
if (rc)
errs++;
}
return errs;
}
static void jl_serialize_methlist(ios_t *s, jl_methlist_t *ml)
{
while (ml != NULL) {
jl_serialize_value(s, ml->sig);
assert(jl_is_tuple(ml->sig));
write_int8(s, ml->va);
jl_serialize_value(s, ml->tvars);
jl_serialize_value(s, ml->func);
jl_serialize_value(s, ml->invokes);
ml = ml->next;
}
jl_serialize_value(s, NULL);
}
void SAS::associate_trails(TrailId trail_a,
TrailId trail_b,
Marker::Scope scope)
{
std::string trail_assoc_msg;
write_hdr(trail_assoc_msg, 29, SAS_MSG_TRAIL_ASSOC, get_current_timestamp());
write_trail(trail_assoc_msg, trail_a);
write_trail(trail_assoc_msg, trail_b);
write_int8(trail_assoc_msg, (uint8_t)scope);
if (_connection)
{
_connection->send_msg(trail_assoc_msg);
}
}
struct data_buffer *gen_ldb_control_packet(char *cmd, MEM_POOL *mem_pool)
{
// make cmd to full command
while (strtok(NULL, " "));
struct data_buffer *dbuf = init_data_buffer();
// header
write_int32(0, dbuf);
write_int8(1, dbuf);
write_int8(1, dbuf);
write_int16(MT_CD_EXE_LDB_CONTROL, dbuf);
write_int32(0, dbuf);
//timeout
write_int32(0, dbuf);
write_int32(strlen(cmd), dbuf);
write_bytes((uint8_t *)cmd, strlen(cmd), dbuf);
fill_int32(dbuf->data_len, dbuf, 0);
return dbuf;
}
int
bson_encoder_append_double(bson_encoder_t encoder, const char *name, double value)
{
CODER_CHECK(encoder);
if (write_int8(encoder, BSON_DOUBLE) ||
write_name(encoder, name) ||
write_double(encoder, value)) {
CODER_KILL(encoder, "write error on BSON_DOUBLE");
}
return 0;
}
int
bson_encoder_fini(bson_encoder_t encoder)
{
CODER_CHECK(encoder);
if (write_int8(encoder, BSON_EOO)) {
CODER_KILL(encoder, "write error on document terminator");
}
/* sync file */
if (encoder->fd > -1) {
BSON_FSYNC(encoder->fd);
}
return 0;
}
int
bson_encoder_append_string(bson_encoder_t encoder, const char *name, const char *string)
{
size_t len;
CODER_CHECK(encoder);
len = strlen(string) + 1; /* include trailing nul */
if (write_int8(encoder, BSON_STRING) ||
write_name(encoder, name) ||
write_int32(encoder, len) ||
write_x(encoder, string, len)) {
CODER_KILL(encoder, "write error on BSON_STRING");
}
return 0;
}
TEST(DATA_BUFFER_TEST, READ_AND_WRITE){
MEM_POOL_PTR pMemPool = mem_pool_init(MB_SIZE);
struct data_buffer* buffer = init_data_buffer();
buffer->data_len = 256;
buffer->data = (uint8*) mem_pool_malloc(pMemPool, 256);
uint8 tmp8;
uint16 tmp16;
uint32 tmp32;
uint64 tmp64;
char* str = (char*) mem_pool_malloc(pMemPool, 100);
char* result = (char*) mem_pool_malloc(pMemPool, 100);
strcpy(str, "hello world!");
write_int8(122, buffer);
write_int16(1111, buffer);
write_int32(324, buffer);
write_int64(2321, buffer);
write_bytes((uint8*)str, strlen(str)+1, buffer);
tmp8 = read_int8(buffer);
ASSERT_EQ(tmp8, 122);
tmp16 = read_int16(buffer);
ASSERT_EQ(tmp16, 1111);
tmp32 = read_int32(buffer);
ASSERT_EQ(tmp32, 324);
tmp64 = read_int64(buffer);
ASSERT_EQ(tmp64, 2321);
read_bytes(buffer, (uint8*)result, strlen(str)+1);
ASSERT_EQ(0, strcmp(str, result));
destroy_data_buffer(buffer);
mem_pool_destroy(pMemPool);
}
static void jl_serialize_value_(ios_t *s, jl_value_t *v)
{
if (v == NULL) {
write_uint8(s, Null_tag);
return;
}
void **bp = ptrhash_bp(&ser_tag, v);
if (*bp != HT_NOTFOUND) {
write_as_tag(s, (uint8_t)(ptrint_t)*bp);
return;
}
if (tree_literal_values) {
// compressing tree
if (!is_ast_node(v)) {
writetag(s, (jl_value_t*)LiteralVal_tag);
write_uint16(s, literal_val_id(v));
return;
}
}
else {
bp = ptrhash_bp(&backref_table, v);
if (*bp != HT_NOTFOUND) {
write_uint8(s, BackRef_tag);
write_int32(s, (ptrint_t)*bp);
return;
}
ptrhash_put(&backref_table, v, (void*)(ptrint_t)ios_pos(s));
}
size_t i;
if (jl_is_tuple(v)) {
size_t l = ((jl_tuple_t*)v)->length;
if (l <= 255) {
writetag(s, jl_tuple_type);
write_uint8(s, (uint8_t)l);
}
else {
writetag(s, (jl_value_t*)LongTuple_tag);
write_int32(s, l);
}
for(i=0; i < l; i++) {
jl_serialize_value(s, jl_tupleref(v, i));
}
}
else if (jl_is_symbol(v)) {
size_t l = strlen(((jl_sym_t*)v)->name);
if (l <= 255) {
writetag(s, jl_symbol_type);
write_uint8(s, (uint8_t)l);
}
else {
writetag(s, (jl_value_t*)LongSymbol_tag);
write_int32(s, l);
}
ios_write(s, ((jl_sym_t*)v)->name, l);
}
else if (jl_is_array(v)) {
jl_array_t *ar = (jl_array_t*)v;
writetag(s, (jl_value_t*)jl_array_type);
jl_serialize_value(s, ar->type);
jl_value_t *elty = jl_tparam0(ar->type);
for (i=0; i < ar->ndims; i++)
jl_serialize_value(s, jl_box_long(jl_array_dim(ar,i)));
if (jl_is_bits_type(elty)) {
size_t tot = ar->length * ar->elsize;
ios_write(s, ar->data, tot);
}
else {
for(i=0; i < ar->length; i++) {
jl_serialize_value(s, jl_cellref(v, i));
}
}
}
else if (jl_is_expr(v)) {
jl_expr_t *e = (jl_expr_t*)v;
size_t l = e->args->length;
if (l <= 255) {
writetag(s, jl_expr_type);
write_uint8(s, (uint8_t)l);
}
else {
writetag(s, (jl_value_t*)LongExpr_tag);
write_int32(s, l);
}
jl_serialize_value(s, e->head);
jl_serialize_value(s, e->etype);
for(i=0; i < l; i++) {
jl_serialize_value(s, jl_exprarg(e, i));
}
}
else if (jl_is_some_tag_type(v)) {
jl_serialize_tag_type(s, v);
}
else if (jl_is_typevar(v)) {
writetag(s, jl_tvar_type);
jl_serialize_value(s, ((jl_tvar_t*)v)->name);
jl_serialize_value(s, ((jl_tvar_t*)v)->lb);
jl_serialize_value(s, ((jl_tvar_t*)v)->ub);
write_int8(s, ((jl_tvar_t*)v)->bound);
}
else if (jl_is_function(v)) {
writetag(s, jl_func_kind);
jl_serialize_value(s, v->type);
jl_function_t *f = (jl_function_t*)v;
jl_serialize_value(s, (jl_value_t*)f->linfo);
jl_serialize_value(s, f->env);
if (f->linfo && f->linfo->ast &&
(jl_is_expr(f->linfo->ast) || jl_is_tuple(f->linfo->ast)) &&
f->fptr != &jl_trampoline) {
write_int32(s, 0);
}
else {
jl_serialize_fptr(s, f->fptr);
}
}
else if (jl_is_lambda_info(v)) {
writetag(s, jl_lambda_info_type);
jl_lambda_info_t *li = (jl_lambda_info_t*)v;
jl_serialize_value(s, li->ast);
jl_serialize_value(s, (jl_value_t*)li->sparams);
// don't save cached type info for code in the Base module, because
// it might reference types in the old System module.
if (li->module == jl_base_module)
jl_serialize_value(s, (jl_value_t*)jl_null);
else
jl_serialize_value(s, (jl_value_t*)li->tfunc);
jl_serialize_value(s, (jl_value_t*)li->name);
jl_serialize_value(s, (jl_value_t*)li->specTypes);
jl_serialize_value(s, (jl_value_t*)li->specializations);
jl_serialize_value(s, (jl_value_t*)li->inferred);
jl_serialize_value(s, (jl_value_t*)li->file);
jl_serialize_value(s, (jl_value_t*)li->line);
jl_serialize_value(s, (jl_value_t*)li->module);
}
else if (jl_typeis(v, jl_module_type)) {
jl_serialize_module(s, (jl_module_t*)v);
}
else if (jl_typeis(v, jl_methtable_type)) {
writetag(s, jl_methtable_type);
jl_methtable_t *mt = (jl_methtable_t*)v;
jl_serialize_methlist(s, mt->defs);
jl_serialize_methlist(s, mt->cache);
jl_serialize_value(s, mt->cache_1arg);
write_int32(s, mt->max_args);
}
else if (jl_typeis(v, jl_task_type)) {
jl_error("Task cannot be serialized");
}
else {
jl_value_t *t = (jl_value_t*)jl_typeof(v);
if (jl_is_bits_type(t)) {
void *data = jl_bits_data(v);
if (t == (jl_value_t*)jl_int64_type &&
*(int64_t*)data >= S32_MIN && *(int64_t*)data <= S32_MAX) {
writetag(s, (jl_value_t*)SmallInt64_tag);
write_int32(s, (int32_t)*(int64_t*)data);
}
else {
int nb = ((jl_bits_type_t*)t)->nbits;
writetag(s, jl_bits_kind);
jl_serialize_value(s, t);
ios_write(s, data, nb/8);
}
}
else if (jl_is_struct_type(t)) {
writetag(s, jl_struct_kind);
jl_serialize_value(s, t);
size_t nf = ((jl_struct_type_t*)t)->names->length;
size_t i;
for(i=0; i < nf; i++) {
jl_value_t *fld = ((jl_value_t**)v)[i+1];
jl_serialize_value(s, fld);
}
if (t == jl_idtable_type) {
jl_cell_1d_push(idtable_list, v);
}
}
else {
assert(0);
}
}
}
void save_ns_dbase(void)
{
dbFILE *f;
int i;
NickInfo *ni;
char **access;
static time_t lastwarn = 0;
if (!(f = open_db(s_NickServ, NickDBName, "w")))
return;
for (ni = firstnick(); ni; ni = nextnick()) {
SAFE(write_int8(1, f));
SAFE(write_buffer(ni->nick, f));
SAFE(write_buffer(ni->pass, f));
SAFE(write_string(ni->url, f));
SAFE(write_string(ni->email, f));
SAFE(write_string(ni->last_usermask, f));
SAFE(write_string(ni->last_realname, f));
SAFE(write_string(ni->last_quit, f));
SAFE(write_int32(ni->time_registered, f));
SAFE(write_int32(ni->last_seen, f));
SAFE(write_int16(ni->status, f));
if (ni->link) {
SAFE(write_string(ni->link->nick, f));
SAFE(write_int16(ni->linkcount, f));
SAFE(write_int16(ni->channelcount, f));
} else {
SAFE(write_string(NULL, f));
SAFE(write_int16(ni->linkcount, f));
SAFE(write_int32(ni->flags, f));
SAFE(write_ptr(ni->suspendinfo, f));
if (ni->suspendinfo) {
SAFE(write_buffer(ni->suspendinfo->who, f));
SAFE(write_string(ni->suspendinfo->reason, f));
SAFE(write_int32(ni->suspendinfo->suspended, f));
SAFE(write_int32(ni->suspendinfo->expires, f));
}
SAFE(write_int16(ni->accesscount, f));
for (i=0, access=ni->access; i<ni->accesscount; i++, access++)
SAFE(write_string(*access, f));
SAFE(write_int16(ni->channelcount, f));
SAFE(write_int16(ni->channelmax, f));
SAFE(write_int16(ni->language, f));
}
} /* for (ni) */
{
/* This is an UGLY HACK but it simplifies loading. It will go away
* in the next file version */
static char buf[256];
SAFE(write_buffer(buf, f));
}
close_db(f);
return;
fail:
restore_db(f);
log_perror("Write error on %s", NickDBName);
if (time(NULL) - lastwarn > WarningTimeout) {
wallops(NULL, "Write error on %s: %s", NickDBName,
strerror(errno));
lastwarn = time(NULL);
}
}
/* Writes instructions within a basic block boundary. */
void write_instructions(MVMThreadContext *tc, MVMSpeshGraph *g, SpeshWriterState *ws, MVMSpeshBB *bb) {
MVMSpeshIns *ins = bb->first_ins;
while (ins) {
MVMint32 i;
/* Process any annotations. */
MVMSpeshAnn *ann = ins->annotations;
MVMSpeshAnn *deopt_one_ann = NULL;
MVMSpeshAnn *deopt_all_ann = NULL;
MVMSpeshAnn *deopt_inline_ann = NULL;
while (ann) {
switch (ann->type) {
case MVM_SPESH_ANN_FH_START:
ws->handlers[ann->data.frame_handler_index].start_offset =
ws->bytecode_pos;
break;
case MVM_SPESH_ANN_FH_END:
ws->handlers[ann->data.frame_handler_index].end_offset =
ws->bytecode_pos;
break;
case MVM_SPESH_ANN_FH_GOTO:
ws->handlers[ann->data.frame_handler_index].goto_offset =
ws->bytecode_pos;
break;
case MVM_SPESH_ANN_DEOPT_ONE_INS:
deopt_one_ann = ann;
break;
case MVM_SPESH_ANN_DEOPT_ALL_INS:
deopt_all_ann = ann;
break;
case MVM_SPESH_ANN_INLINE_START:
g->inlines[ann->data.inline_idx].start = ws->bytecode_pos;
break;
case MVM_SPESH_ANN_INLINE_END:
g->inlines[ann->data.inline_idx].end = ws->bytecode_pos;
break;
case MVM_SPESH_ANN_DEOPT_INLINE:
deopt_inline_ann = ann;
break;
case MVM_SPESH_ANN_DEOPT_OSR:
g->deopt_addrs[2 * ann->data.deopt_idx + 1] = ws->bytecode_pos;
break;
}
ann = ann->next;
}
if (ins->info->opcode != MVM_SSA_PHI) {
/* Real instruction, not a phi. Emit opcode. */
if (ins->info->opcode == (MVMuint16)-1) {
/* Ext op; resolve. */
MVMExtOpRecord *extops = g->sf->body.cu->body.extops;
MVMuint16 num_extops = g->sf->body.cu->body.num_extops;
MVMint32 found = 0;
for (i = 0; i < num_extops; i++) {
if (extops[i].info == ins->info) {
write_int16(ws, MVM_OP_EXT_BASE + i);
found = 1;
break;
}
}
if (!found)
MVM_exception_throw_adhoc(tc, "Spesh: failed to resolve extop in code-gen");
}
else {
/* Core op. */
write_int16(ws, ins->info->opcode);
}
/* Write out operands. */
for (i = 0; i < ins->info->num_operands; i++) {
MVMuint8 flags = ins->info->operands[i];
MVMuint8 rw = flags & MVM_operand_rw_mask;
switch (rw) {
case MVM_operand_read_reg:
case MVM_operand_write_reg:
write_int16(ws, ins->operands[i].reg.orig);
break;
case MVM_operand_read_lex:
case MVM_operand_write_lex:
write_int16(ws, ins->operands[i].lex.idx);
write_int16(ws, ins->operands[i].lex.outers);
break;
case MVM_operand_literal: {
MVMuint8 type = flags & MVM_operand_type_mask;
switch (type) {
case MVM_operand_int8:
write_int8(ws, ins->operands[i].lit_i8);
break;
case MVM_operand_int16:
write_int16(ws, ins->operands[i].lit_i16);
break;
case MVM_operand_int32:
write_int32(ws, ins->operands[i].lit_i32);
break;
case MVM_operand_int64:
write_int64(ws, ins->operands[i].lit_i64);
break;
case MVM_operand_num32:
write_num32(ws, ins->operands[i].lit_n32);
break;
case MVM_operand_num64:
write_num64(ws, ins->operands[i].lit_n64);
break;
case MVM_operand_callsite:
write_int16(ws, ins->operands[i].callsite_idx);
break;
case MVM_operand_coderef:
write_int16(ws, ins->operands[i].coderef_idx);
break;
case MVM_operand_str:
write_int32(ws, ins->operands[i].lit_str_idx);
break;
case MVM_operand_ins: {
MVMint32 offset = ws->bb_offsets[ins->operands[i].ins_bb->idx];
if (offset >= 0) {
/* Already know where it is, so just write it. */
write_int32(ws, offset);
}
else {
/* Need to fix it up. */
if (ws->num_fixups == ws->alloc_fixups) {
ws->alloc_fixups *= 2;
ws->fixup_locations = MVM_realloc(ws->fixup_locations,
ws->alloc_fixups * sizeof(MVMint32));
ws->fixup_bbs = MVM_realloc(ws->fixup_bbs,
ws->alloc_fixups * sizeof(MVMSpeshBB *));
}
ws->fixup_locations[ws->num_fixups] = ws->bytecode_pos;
ws->fixup_bbs[ws->num_fixups] = ins->operands[i].ins_bb;
write_int32(ws, 0);
ws->num_fixups++;
}
break;
}
case MVM_operand_spesh_slot:
write_int16(ws, ins->operands[i].lit_i16);
break;
default:
MVM_exception_throw_adhoc(tc,
"Spesh: unknown operand type %d in codegen (op %s)",
(int)type, ins->info->name);
}
}
break;
default:
MVM_exception_throw_adhoc(tc, "Spesh: unknown operand type in codegen");
}
}
}
/* If there was a deopt point annotation, update table. */
if (deopt_one_ann)
g->deopt_addrs[2 * deopt_one_ann->data.deopt_idx + 1] = ws->bytecode_pos;
if (deopt_all_ann)
g->deopt_addrs[2 * deopt_all_ann->data.deopt_idx + 1] = ws->bytecode_pos;
if (deopt_inline_ann)
g->deopt_addrs[2 * deopt_inline_ann->data.deopt_idx + 1] = ws->bytecode_pos;
ins = ins->next;
}
}
bool SAS::Connection::connect_init()
{
if (_socket_callback)
{
_sock = _socket_callback(_sas_address.c_str(), SAS_PORT);
}
else
{
_sock = get_local_sock(_sas_address.c_str(), SAS_PORT);
}
if (_sock < 0)
{
return false;
}
SAS_LOG_DEBUG("Connected SAS socket to %s:%s", _sas_address.c_str(), SAS_PORT);
set_send_timeout(_sock, SEND_TIMEOUT);
// Send an init message to SAS.
std::string init;
std::string version("v0.1");
// The resource version is part of the binary protocol but is not currently
// exposed over the C++ API.
std::string resource_version("");
int init_len = INIT_HDR_SIZE +
sizeof(uint8_t) + _system_name.length() +
sizeof(uint32_t) +
sizeof(uint8_t) + version.length() +
sizeof(uint8_t) + _system_type.length() +
sizeof(uint8_t) + _resource_identifier.length() +
sizeof(uint8_t) + resource_version.length();
init.reserve(init_len);
write_hdr(init, init_len, SAS_MSG_INIT, get_current_timestamp());
write_int8(init, (uint8_t)_system_name.length());
write_data(init, _system_name.length(), _system_name.data());
int endianness = 1;
init.append((char*)&endianness, sizeof(int)); // Endianness must be written in machine order.
write_int8(init, version.length());
write_data(init, version.length(), version.data());
write_int8(init, (uint8_t)_system_type.length());
write_data(init, _system_type.length(), _system_type.data());
write_int8(init, (uint8_t)_resource_identifier.length());
write_data(init, _resource_identifier.length(), _resource_identifier.data());
write_int8(init, (uint8_t)resource_version.length());
write_data(init, resource_version.length(), resource_version.data());
SAS_LOG_DEBUG("Sending SAS INIT message");
int rc = ::send(_sock, init.data(), init.length(), 0);
if (rc < 0)
{
SAS_LOG_ERROR("SAS connection to %s:%s failed: %d %s", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno));
::close(_sock);
_sock = -1;
return false;
}
SAS_LOG_STATUS("Connected to SAS %s:%s", _sas_address.c_str(), SAS_PORT);
return true;
}
/* Terminates an IFF chunk header, by padding to a 2-byte boundary. */
static bool chunk_end(IOStream *ios, size_t size)
{
return (size&1) ? write_int8(ios, 0) : true;
}
