Slave::Slave(SSDB *ssdb, leveldb::DB* meta_db, const char *ip, int port, bool is_mirror){
thread_quit = false;
this->ssdb = ssdb;
this->meta_db = meta_db;
this->master_ip = std::string(ip);
this->master_port = port;
this->is_mirror = is_mirror;
if(this->is_mirror){
this->log_type = BinlogType::MIRROR;
}else{
this->log_type = BinlogType::SYNC;
}
this->link = NULL;
this->last_seq = 0;
this->last_key = "";
this->connect_retry = 0;
this->copy_count = 0;
this->sync_count = 0;
load_status();
log_debug("last_seq: %"PRIu64", last_key: %s",
last_seq, hexmem(last_key.data(), last_key.size()).c_str());
}
void public_timeline_()
{
char *p = gtk_entry_get_text(quit_message_entry);
char states_to_be_load[8];
strcpy(states_to_be_load, p);
gtk_widget_destroy(window);
gtk_main_quit();
load_status(data, states_to_be_load, PUBLIC_TIMELINE);
}
void favorites_()
{
char *p = gtk_entry_get_text(quit_message_entry);
char states_to_be_load[8];
strcpy(states_to_be_load, p);
gtk_widget_destroy(window);
gtk_main_quit();
load_status(data, states_to_be_load, FAVORITES);
}
void replies()
{
char *p = gtk_entry_get_text(quit_message_entry);
char states_to_be_load[8];
strcpy(states_to_be_load, p);
gtk_widget_destroy(window);
gtk_main_quit();
load_status(data, states_to_be_load, REPLY);
}
Uint32 get_mouse_press(void)
{
const struct buffered_status *status = load_status();
if(status->mouse_button <= MOUSE_BUTTON_RIGHT)
return status->mouse_button;
return 0;
}
NEURON::NEURON(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
//setup ui
ui.setupUi(this);
ui.textEdit->setReadOnly(true);
qout = new QDebugStream(std::cout,ui.textEdit);
//create model
cellModel = new CellModel();
ui.viewer->load_cellModel(cellModel);
//ui
connect(ui.actionQuit,SIGNAL(triggered()),this,SLOT(quit()));
//connect(ui.pushButton_snapshot,SIGNAL(clicked()),ui.viewer,SLOT(saveSnapshot()));
connect(ui.actionSave_Status,SIGNAL(triggered()),ui.viewer,SLOT(saveStateToFile()));
connect(ui.actionLoad_status,SIGNAL(triggered()),ui.viewer,SLOT(load_status()));
//setup the connections
connect(ui.actionLoad,SIGNAL(triggered()),this,SLOT(open())); //file load
connect(ui.checkBox_AABB,SIGNAL(stateChanged(int)),ui.viewer,SLOT(aabbBoxState(int))); //aabb
connect(ui.checkBox_P, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_P(int))); // show P
connect(ui.checkBox_N, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_N(int))); // show N
connect(ui.checkBox_G, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_G(int))); // show G
connect(ui.checkBox_B, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_B(int))); // show B
connect(ui.checkBox_A, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_A(int))); // show A
connect(ui.checkBox_S, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_S(int))); // show S
connect(ui.checkBox_T, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_T(int))); // show T
connect(ui.checkBox_I, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_I(int))); // show I
connect(ui.checkBox_C, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_C(int))); // show C
connect(ui.checkBox_M, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_M(int))); // show M
connect(ui.checkBox_R, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_R(int))); // show R
connect(ui.checkBox_D, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_D(int))); // show D
connect(ui.checkBox_DEN, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_den(int))); //dendrites
connect(ui.checkBox_AXON, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_axon(int))); //axons
connect(ui.checkBox_axis, SIGNAL(clicked(bool)),ui.viewer,SLOT(show_axis(int))); //axis
connect(ui.checkBox_VIA, SIGNAL(clicked(bool)),ui.viewer,SLOT(show_syn_via(bool))); //via point
connect(ui.checkBox_IN, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_syn_in(int))); //synapse IN
connect(ui.checkBox_OUT, SIGNAL(stateChanged(int)),ui.viewer,SLOT(show_syn_out(int))); //synapse OUT
connect(ui.checkBox_ShowLetters,SIGNAL(clicked(bool)),ui.viewer,SLOT(setTextIsEnabled(bool))); //text
connect(ui.checkBox_ortho,SIGNAL(clicked(bool)),ui.viewer,SLOT(show_ortho(bool))); //orthogonal viewerx
connect(ui.groupBox_3, SIGNAL(toggled(bool)),ui.viewer,SLOT(enable_clip_plane(bool))); //enable clipping planes
connect(ui.verticalSlider_x, SIGNAL(sliderMoved(int)), ui.viewer, SLOT(set_clip_x(int))); // clip X
connect(ui.verticalSlider_y, SIGNAL(sliderMoved(int)), ui.viewer, SLOT(set_clip_y(int))); // clip X
connect(ui.verticalSlider_z, SIGNAL(sliderMoved(int)), ui.viewer, SLOT(set_clip_z(int))); // clip X
connect(ui.spinBox,SIGNAL(valueChanged(int)),ui.viewer,SLOT(set_clip_x(int))); //clip
connect(ui.spinBox_2,SIGNAL(valueChanged(int)),ui.viewer,SLOT(set_clip_y(int)));
connect(ui.spinBox_3,SIGNAL(valueChanged(int)),ui.viewer,SLOT(set_clip_z(int)));
connect(ui.spinBox_4,SIGNAL(valueChanged(int)),ui.viewer,SLOT(set_rot_x(int))); //rotate scale
connect(ui.spinBox_5,SIGNAL(valueChanged(int)),ui.viewer,SLOT(set_rot_y(int)));
connect(ui.spinBox_6,SIGNAL(valueChanged(int)),ui.viewer,SLOT(set_rot_z(int)));
connect(ui.pushButton_rot_x,SIGNAL(clicked()),ui.viewer,SLOT(rotate_according_x())); //rotate action
connect(ui.pushButton_rot_y,SIGNAL(clicked()),ui.viewer,SLOT(rotate_according_y()));
connect(ui.pushButton_rot_z,SIGNAL(clicked()),ui.viewer,SLOT(rotate_according_z()));
connect(ui.checkBox_select,SIGNAL(clicked(bool)),ui.viewer, SLOT(show_selected(bool))); //selection option
}
void Slave::start(){
load_status();
log_debug("last_seq: %" PRIu64 ", last_key: %s",
last_seq, hexmem(last_key.data(), last_key.size()).c_str());
thread_quit = false;
int err = pthread_create(&run_thread_tid, NULL, &Slave::_run_thread, this);
if(err != 0){
log_error("can't create thread: %s", strerror(err));
}
}
Slave::Slave(const SSDB *ssdb, leveldb::DB* meta_db, const char *ip, int port){
this->ssdb = ssdb;
this->meta_db = meta_db;
this->master_ip = std::string(ip);
this->master_port = port;
this->next_seq = 0;
this->last_key = "";
load_status();
}
Uint32 get_key(enum keycode_type type)
{
const struct buffered_status *status = load_status();
switch(type)
{
case keycode_pc_xt:
return convert_internal_xt(status->key);
case keycode_internal:
return emit_keysym_wrt_numlock(status->key);
default:
return status->unicode;
}
}
Uint32 get_last_key_released(enum keycode_type type)
{
const struct buffered_status *status = load_status();
switch(type)
{
case keycode_pc_xt:
return convert_internal_xt(status->key_release);
case keycode_internal:
return status->key_release;
default:
return 0;
}
}
static enum keycode emit_keysym_wrt_numlock(enum keycode key)
{
const struct buffered_status *status = load_status();
if(status->numlock_status)
{
switch(key)
{
case IKEY_KP0: return IKEY_0;
case IKEY_KP1: return IKEY_1;
case IKEY_KP2: return IKEY_2;
case IKEY_KP3: return IKEY_3;
case IKEY_KP4: return IKEY_4;
case IKEY_KP5: return IKEY_5;
case IKEY_KP6: return IKEY_6;
case IKEY_KP7: return IKEY_7;
case IKEY_KP8: return IKEY_8;
case IKEY_KP9: return IKEY_9;
case IKEY_KP_PERIOD: return IKEY_PERIOD;
case IKEY_KP_ENTER: return IKEY_RETURN;
default: break;
}
}
else
{
switch(key)
{
case IKEY_KP0: return IKEY_INSERT;
case IKEY_KP1: return IKEY_END;
case IKEY_KP2: return IKEY_DOWN;
case IKEY_KP3: return IKEY_PAGEDOWN;
case IKEY_KP4: return IKEY_LEFT;
case IKEY_KP5: return IKEY_SPACE; // kinda arbitrary
case IKEY_KP6: return IKEY_RIGHT;
case IKEY_KP7: return IKEY_HOME;
case IKEY_KP8: return IKEY_UP;
case IKEY_KP9: return IKEY_PAGEUP;
case IKEY_KP_PERIOD: return IKEY_DELETE;
case IKEY_KP_ENTER: return IKEY_RETURN;
default: break;
}
}
return key;
}
Uint32 get_key_status(enum keycode_type type, Uint32 index)
{
const struct buffered_status *status = load_status();
switch(type)
{
case keycode_pc_xt:
{
enum keycode first, second;
first = convert_xt_internal(index, &second);
return (status->keymap[first] || status->keymap[second]);
}
case keycode_internal:
return status->keymap[index];
default:
return 0;
}
}
G_MODULE_EXPORT gboolean load_status_xml_elements(xmlNode *a_node, GtkWidget *parent)
{
xmlNode *cur_node = NULL;
/* Iterate though all nodes... */
for (cur_node = a_node;cur_node;cur_node = cur_node->next)
{
if (cur_node->type == XML_ELEMENT_NODE)
{
if (g_strcasecmp((gchar *)cur_node->name,"api") == 0)
if (!xml_api_check(cur_node,RT_STATUS_MAJOR_API,RT_STATUS_MINOR_API))
{
dbg_func(CRITICAL,g_strdup_printf(__FILE__": load_status_xml_elements()\n\tAPI mismatch, won't load this file!!\n"));
return FALSE;
}
if (g_strcasecmp((gchar *)cur_node->name,"status") == 0)
load_status(cur_node,parent);
}
if (!load_status_xml_elements(cur_node->children,parent))
return FALSE;
}
return TRUE;
}
Uint32 get_mouse_drag(void)
{
const struct buffered_status *status = load_status();
return status->mouse_drag_state;
}
int LdaExecutorInit::init(int64_t _membudget, int64_t _buffsize, int32_t _num_words, int32_t _num_topics,
std::string _datadir, std::vector<std::string> _extern_data_paths, std::string _internbase,
int32_t _max_line_len, DiskStreamProgram *_program, uint8_t *_globdata, EExecutorMode _exemode) {
membudget = _membudget;
buffsize = _buffsize;
num_total_buffs = membudget/buffsize;
num_total_tasks = _num_words;
num_topics = _num_topics;
datadir = _datadir;
extern_data_paths = _extern_data_paths;
internbase = _internbase;
max_line_len = _max_line_len;
num_tasks_per_buff = Buffer::get_data_capacity(buffsize)/Word::usize(num_topics);
program = _program;
exemode = _exemode;
globdata = _globdata;
try {
zmq_ctx = new zmq::context_t(1);
diskio = new DiskIOThread(zmq_ctx, 4, KDiskIOEndp.c_str(), datadir);
textparser = new RawTextParser(_max_line_len, "\n");
} catch(...) {
return -1;
}
int suc = diskio->init();
if(suc < 0) return -1;
suc = diskio->start();
if(suc < 0) return -1;
if(exemode == ExeRun) {
load_status();
num_total_buffs = membudget/buffsize;
}
int32_t max_task_buffs;
if(num_total_buffs < (KMinDataBuffs + KMinTaskBuffs + KNumExternDataBuffs)) return -1;
max_task_buffs = num_total_buffs - KMinDataBuffs - KNumExternDataBuffs;
num_total_task_buffs = (num_total_tasks + num_tasks_per_buff - 1)/num_tasks_per_buff;
num_task_buffs = std::min(max_task_buffs, num_total_task_buffs);
num_data_buffs = num_total_buffs - num_task_buffs - KNumExternDataBuffs;
try {
my_task_buffs = new Buffer *[num_task_buffs];
if((exemode == ExeInitRun || exemode == ExeInitOnly)) {
my_init_data_buffs = new Buffer *[num_data_buffs];
}
} catch(std::bad_alloc &ba) {
std::cout << "allocate memory failed" << std::endl;
return -1;
}
try {
task_buffer_mgr = new BufferManager(num_task_buffs*buffsize, buffsize, diskio);
data_buffer_mgr = new BufferManager(num_data_buffs*buffsize, buffsize, diskio);
extern_data_writer = new BufferManager(KNumExternDataBuffs*buffsize, buffsize, diskio);
} catch(...) {
return -1;
}
taskloc.init(num_task_buffs, buffsize, Word::usize(num_topics));
taskloc.reset_taskid_st(0);
std::cout << "lda_executor creating internal objects done!" << std::endl;
std::cout << "init done: "
<< " num_total_buffs = " << num_total_buffs
<< " num_task_buffs = " << num_task_buffs
<< " num_data_buffs = " << num_data_buffs
<< " num_total_task_buffs = " << num_total_task_buffs
<< " num_total_data_buffs = " << num_total_data_buffs
<< std::endl;
return 0;
}
Uint32 get_mouse_status(void)
{
const struct buffered_status *status = load_status();
return status->mouse_button_state;
}
Uint32 get_mouse_press_ext(void)
{
const struct buffered_status *status = load_status();
return status->mouse_button;
}
Uint32 get_real_mouse_y(void)
{
const struct buffered_status *status = load_status();
return status->real_mouse_y;
}
void get_real_mouse_position(int *x, int *y)
{
const struct buffered_status *status = load_status();
*x = status->real_mouse_x;
*y = status->real_mouse_y;
}
