/**
* @brief f1_dht_block early: disable the display word task
*/
void alto2_cpu_device::f1_early_dht_block()
{
m_dsp.dht_blocks = true;
// clear the wakeup for the display horizontal task
m_task_wakeup &= ~(1 << m_task);
LOG((this,LOG_DHT,2," BLOCK %s\n", task_name(m_task)));
}
/***************************************************************************
*
* Name: finish_control_rpt()
*
* Description:
*
* Input: none
* Output: none
* Returns: none
*
****************************************************************************
*/
void finish_control_rpt(void)
{
fprintf(RptFileFD, "\n End of Report\n");
fflush(RptFileFD);
fclose(RptFileFD);
if (strcmp(task_name(), CREATE_TASK) == 0) {
emit(FILE_LINE, EFT_CNTLRPT, CREATE_TASK);
} else if (strcmp(task_name(), PROCESS_TASK) == 0) {
emit(FILE_LINE, EFT_CNTLRPT, PROCESS_TASK);
} else if (strcmp(task_name(), POST_TASK) == 0) {
emit(FILE_LINE, EFT_CNTLRPT, POST_TASK);
}
sleep(2); /* In case another report gets created at about the same time */
}
static void
queue_task (RBMtpThread *thread, RBMtpThreadTask *task)
{
char *name = task_name (task);
rb_debug ("queueing task: %s", name);
g_free (name);
g_async_queue_push (thread->queue, task);
}
/**
* @brief block the display word task
*/
void alto2_cpu_device::f1_early_dwt_block()
{
m_dsp.dwt_blocks = true;
/* clear the wakeup for the display word task */
m_task_wakeup &= ~(1 << m_task);
LOG((LOG_DWT,2," BLOCK %s\n", task_name(m_task)));
/* wakeup the display horizontal task, if it didn't block itself */
if (!m_dsp.dht_blocks)
m_task_wakeup |= 1 << task_dht;
}
static int get_status(int pid, char * buffer)
{
char * orig = buffer;
struct task_struct ** p = get_task(pid), *tsk;
if (!p || (tsk = *p) == NULL)
return 0;
buffer = task_name(tsk, buffer);
buffer = task_state(tsk, buffer);
buffer = task_mem(tsk, buffer);
buffer = task_sig(tsk, buffer);
return buffer - orig;
}
bool parse_app_info(const Json::Value& json_app_data, cocaine_node_app_info_t& app_info) {
// parse drivers
Json::Value tasks(json_app_data["drivers"]);
if (!tasks.isObject() || !tasks.size()) {
return false;
}
Json::Value::Members tasks_names(tasks.getMemberNames());
for (Json::Value::Members::iterator it = tasks_names.begin(); it != tasks_names.end(); ++it) {
std::string task_name(*it);
Json::Value task(tasks[task_name]);
if (!task.isObject() || !task.size()) {
continue;
}
cocaine_node_task_info_t task_info(task_name);
if (!parse_task_info(task, task_info)) {
continue;
}
else {
app_info.tasks[task_name] = task_info;
}
}
// parse remaining properties
app_info.queue_depth = json_app_data.get("queue-depth", 0).asInt();
std::string state = json_app_data.get("state", "").asString();
if (state == "running") {
app_info.status = APP_STATUS_RUNNING;
}
else if (state == "stopping") {
app_info.status = APP_STATUS_STOPPING;
}
else if (state == "stopped") {
app_info.status = APP_STATUS_STOPPED;
}
else {
app_info.status = APP_STATUS_UNKNOWN;
}
const Json::Value slaves_props = json_app_data["slaves"];
if (slaves_props.isObject()) {
app_info.slaves_busy = slaves_props.get("busy", 0).asInt();
app_info.slaves_total = slaves_props.get("total", 0).asInt();
}
return true;
}
const char* test_name(const char* in, int task_num, int wind_num)
{
static char buffer[80];
sprintf(buffer,"%s (task %s, wind %s)", in, task_name(task_num), wind_name(wind_num));
return buffer;
}
//! f1_mrt_block early: block the display word task
void alto2_cpu_device::f1_early_mrt_block()
{
/* clear the wakeup for the memory refresh task */
m_task_wakeup &= ~(1 << m_task);
LOG((this,LOG_MRT,2," BLOCK %s\n", task_name(m_task)));
}
//! f1_ksec_block early: block the disk sector task
void alto2_cpu_device::f1_early_ksec_block()
{
LOG((this,LOG_KSEC,2," BLOCK %s\n", task_name(m_task)));
disk_block(m_task);
}
/**
* @brief f1_dvt_block early: disable the display word task
*/
void alto2_cpu_device::f1_early_dvt_block()
{
// m_task_wakeup &= ~(1 << m_task);
LOG((this,LOG_DVT,2," BLOCK %s\n", task_name(m_task)));
}
/**
* @brief disable the cursor task and set the curt_blocks flag
*/
void alto2_cpu_device::f1_early_curt_block()
{
m_dsp.curt_blocks = true;
m_task_wakeup &= ~(1 << m_task);
LOG((LOG_CURT,2," BLOCK %s\n", task_name(m_task)));
}
// Call back for querying the text of a
// menu item, or menu.
// Expect item names like /1 & /3/4, and
// Menu names like / & /3/
static char *task_cb_item_text(char *name) {
// Deconstruct the menu ID
APP_LOG(APP_LOG_LEVEL_DEBUG, "task_cb_item_text(%s)", name);
uint8_t parts[MAX_MENU_DEPTH];
int num_parts = menu_parts(name, parts);
char *rc = NULL;
// It's a menu if the ID ends with a '/'
bool is_menu = (name[strlen(name)-1] == '/');
if (num_parts == 0) {
rc = "Categories";
}
else if ((num_parts == 1) && (parts[0] == 1)) {
rc = "Recent";
}
else {
// Get the label ID
uint8_t label_id = 0;
if (parts[0] != 1) {
uint8_t *labels = ordered_labels();
label_id = labels[parts[0]-2];
APP_LOG(APP_LOG_LEVEL_DEBUG, "task_cb_item_text: Translate menu %d to label ID %d", parts[0], label_id);
// If we're looking for a label name, set it up
if (num_parts == 1) {
APP_LOG(APP_LOG_LEVEL_DEBUG, "task_cb_item_text: Get label name for label ID %d", label_id);
rc = label_name(label_id);
}
}
// Handle the "Pause" at the top of the Recents menu
uint8_t task_ix = parts[1] - 1; // Because menu-IDs are 1-based
if (!g_menu_paused && (rc == NULL)) {
APP_LOG(APP_LOG_LEVEL_DEBUG, "task_cb_item_text: Get task name");
if (parts[0] == 1)
{
// Recents menu - ignore the pause option
if (task_ix == 0) {
rc = "Pause";
}
else {
task_ix -= 1; // To make space for the pause option
}
}
}
// Get the task name from the ordered tasks
if (rc == NULL) {
uint8_t *tasks = ordered_tasks(label_id);
uint8_t task_id = tasks[task_ix];
rc = task_name(task_id);
}
}
if (rc == NULL) {
rc = "Unknown";
}
if (strlen(rc) >= MAX_MENU_ITEM_LEN)
{
APP_LOG(APP_LOG_LEVEL_DEBUG, "task_cb_item_text: dumping %s: too long", rc);
rc = "Too long";
}
APP_LOG(APP_LOG_LEVEL_DEBUG, "task_cb_item_text: return %s", rc);
return rc;
}
void* exec_task(void* msg_in) {
int* msg = (int*) msg_in;
rankprintf("Beginning task %s on token %d. Setting status to BUSY.\n", task_name(msg[0]), msg[1]);
//Change status to IDLE
pthread_mutex_lock(&lock);
node_status = STATUS_BUSY;
pthread_mutex_unlock(&lock);
if (TASK_GENVIS == msg[0]) {
//Generate some visibilities
//This won't be needed long term
// msg[0] : task type
// msg[1] : tokenid;
// msg[2] : size
int next_tok=0;
while(token_list[next_tok] != 0 && next_tok < 256) next_tok++;
if(next_tok>=256) throw_error("Too many tokens\n");
token_list[next_tok] = new token;
token_list[next_tok]->tid = msg[1];
token_list[next_tok]->token_type = TOKEN_VIS;
int npts = msg[2];
token_list[next_tok]->size = npts;
//TODO padding for degrid
token_list[next_tok]->data = malloc(sizeof(PRECISION2)*(PAD(npts)+npts)); //in and out
token_list[next_tok]->on_rank = rank;
PRECISION2* vis = (PRECISION2*)token_list[next_tok]->data;
vis += PAD(npts);
//Random visibilities
for(int n=0; n<npts;n++) {
vis[n].x = ((float)rand())/RAND_MAX*1000;
vis[n].y = ((float)rand())/RAND_MAX*1000;
}
} else if (TASK_GENIMG == msg[0]) {
//Generate an image
//This won't be needed long term
// msg[0] : task type
// msg[1] : tokenid
// msg[2] : size
int next_tok=0;
while(token_list[next_tok] != 0 && next_tok < 256) next_tok++;
if(next_tok>=256) throw_error("Too many tokens\n");
token_list[next_tok] = new token;
token_list[next_tok]->tid = msg[1];
token_list[next_tok]->token_type = TOKEN_IMG;
int img_dim = msg[2];
token_list[next_tok]->size = img_dim;
//TODO padding for degrid
token_list[next_tok]->data = malloc(sizeof(PRECISION2)*img_dim*img_dim); //out and in
token_list[next_tok]->on_rank = rank;
PRECISION2* img = (PRECISION2*)token_list[next_tok]->data;
//Some image
for(int x=0; x<img_dim;x++)
for(int y=0; y<img_dim;y++) {
img[x+img_dim*y].x = exp(-((x-1400.0)*(x-1400.0)+(y-3800.0)*(y-3800.0))/8000000.0)+1.0;
img[x+img_dim*y].y = 0.4;
}
} else if (TASK_KILLTOK == msg[0]) {
free(token_list[msg[0]]->data);
delete token_list[msg[0]];
token_list[msg[0]] = NULL;
} else if (TASK_DEGRID == msg[0]) {
// Degrid
// msg[1] : visibility tokenid
// msg[2] : image tokenid
int vistok=0, imgtok=0;
while(token_list[vistok]->tid != msg[1] && vistok<500) vistok++;
if (token_list[vistok]->token_type != TOKEN_VIS)
throw_error("First token passed to degrid "
"does not contain visibilities");
while(token_list[imgtok]->tid != msg[2]&& imgtok<500) imgtok++;
if (token_list[imgtok]->token_type != TOKEN_IMG)
throw_error("Second token passed to degrid "
"is not an image");
int img_size = token_list[imgtok]->size;
PRECISION2* img = (PRECISION2*) token_list[imgtok]->data;
int npts = token_list[vistok]->size;
PRECISION2* out = (PRECISION2*) token_list[vistok]->data;
PRECISION2* in = out + PAD(npts);
PRECISION2* gcf = (PRECISION2*)malloc(sizeof(PRECISION2*)*64*GCF_DIM*GCF_DIM);
init_gcf(gcf, GCF_DIM);
degridGPU(out, in, npts, img, img_size, gcf, GCF_DIM);
} else {
sleep(2);
}
rankprintf("Task complete. Setting status to IDLE.\n");
//Change status to IDLE
pthread_mutex_lock(&lock);
node_status = STATUS_IDLE;
pthread_mutex_unlock(&lock);
return NULL;
}
HDDEDATA W_CALLBACK KapDDECallBack(WORD wTran, WORD wFmt, HCONV hConv,
HSZ hsz1, HSZ hsz2, HDDEDATA hData,
DWORD dwData1, DWORD dwData2)
{
switch (wTran) {
case XTYP_ADVSTART:
case XTYP_ADVSTOP:
{
BOOL bRes = FALSE;
if (wFmt == CF_TEXT)
{
char *cl;
if (!DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
return (HDDEDATA) FALSE;
cl = strchr(return_buffer, ':');
if (cl)
{
DDEINFO ddeInfo;
ATOMID idName;
WORD wType;
cl[0] = '\0';
idName = KppAddAtom(return_buffer);
ddeInfo.idSlot = KppAddAtom(cl + 1);
ddeInfo.idObj = KppGetObjectId(idName, &wType);
ddeInfo.idApp = ddeInfo.idItem = NULLID;
ddeInfo.idTopic = HszToAtom(hsz1);
ddeInfo.hConv = hConv;
if (ddeInfo.idObj)
{
UnwindProtect(cleanup1);
requests++;
switch (wTran) {
case XTYP_ADVSTART:
if (CreateLink(&ddeInfo))
bRes = TRUE;
break;
case XTYP_ADVSTOP:
if (CloseServerLink(&ddeInfo, idName))
bRes = TRUE;
break;
}
cleanup1:
requests--;
EndProtect();
}
}
}
return (HDDEDATA) bRes;
}
case XTYP_EXECUTE:
{
DWORD dwLen;
LPBYTE lpByte = DdeAccessData(hData, &dwLen);
if (lpByte)
{
BOOL bFree = FALSE;
LPBYTE lpCopy;
if (dwLen < RET_BUFFER_LEN)
{
strcpy(return_buffer, lpByte);
lpCopy = return_buffer;
}
else
{
lpCopy = strdup(lpByte);
bFree = TRUE;
}
DdeUnaccessData(hData);
if (lpCopy)
{
UnwindProtect(cleanup2);
requests++;
if (!KppEvalExpString(lpCopy))
KppPostKappaErrorMessageCB();
cleanup2:
requests--;
if (bFree)
free(lpCopy);
EndProtect();
return (HDDEDATA) DDE_FACK;
}
}
return (HDDEDATA) DDE_FNOTPROCESSED;
}
case XTYP_CONNECT:
if (DdeQueryString(dwDDEInst, hsz1, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
char *dot = strrchr(return_buffer, '.');
if (dot)
dot[0] = '\0';
if (!stricmp(DDETopicName, return_buffer) ||
#ifdef MULTI
!stricmp(DDEKappaName, return_buffer) ||
S_ILOC == 0 &&
#endif
!stricmp("KAPPA", return_buffer))
return TRUE;
}
return (HDDEDATA) FALSE;
case XTYP_DISCONNECT:
UnwindProtect(cleanup3);
requests++;
DeleteDDETasks(hConv);
cleanup3:
requests--;
EndProtect();
return (HDDEDATA) NULL;
case XTYP_WILDCONNECT:
{
HSZPAIR hszPair[3];
hszPair[0].hszSvc =
DdeCreateStringHandle(dwDDEInst, DDEAppName, CP_WINANSI);
hszPair[0].hszTopic =
DdeCreateStringHandle(dwDDEInst, DDETopicName, CP_WINANSI);
hszPair[1].hszSvc =
DdeCreateStringHandle(dwDDEInst, DDEAppName, CP_WINANSI);
hszPair[1].hszTopic =
DdeCreateStringHandle(dwDDEInst, DDEKappaName, CP_WINANSI);
hszPair[2].hszSvc = hszPair[2].hszTopic = NULL;
return DdeCreateDataHandle(dwDDEInst, (LPVOID) hszPair,
sizeof(HSZPAIR) * 3, 0,
hszPair[0].hszSvc, CF_TEXT, 0);
}
case XTYP_POKE:
{
UINT flag = DDE_FNOTPROCESSED;
if (wFmt == CF_TEXT &&
DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
ATOMID idSlot;
OBJECTID idObj;
UnwindProtect(cleanup4);
requests++;
idObj = ObjSlotFromItem(return_buffer, &idSlot);
if (idObj && StoreData(lpIDs->idNull, hData, idObj, idSlot))
flag = DDE_FACK;
cleanup4:
requests--;
EndProtect();
}
return (HDDEDATA) flag;
}
case XTYP_REQUEST:
case XTYP_ADVREQ:
hData = (HDDEDATA) DDE_FNOTPROCESSED;
if (wFmt == CF_TEXT &&
DdeQueryString(dwDDEInst, hsz2, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
{
ATOMID idSlot;
OBJECTID idObj;
UnwindProtect(cleanup5);
requests++;
idObj = ObjSlotFromItem(return_buffer, &idSlot);
if (idObj)
{
BOOL bMulti = FALSE;
ITEMID idValue =
Kpp_Get_SlotAnyValue(OBJECT_TYPE(idObj),
idObj, idSlot, (LPWORD) &bMulti);
GLOBALHANDLE hMem = NULL;
LPBYTE lpBytes = NULL;
DWORD dwLen = ValueToString(idValue, bMulti,
&hMem, &lpBytes);
if (dwLen)
{
hData = DdeCreateDataHandle(dwDDEInst, lpBytes, dwLen,
0, hsz2, CF_TEXT, 0);
if (hMem)
{
GLOBALUNLOCK(hMem);
GLOBALFREE(hMem);
}
if (!hData)
hData = (HDDEDATA) DDE_FNOTPROCESSED;
}
}
cleanup5:
requests--;
EndProtect();
}
return hData;
case XTYP_REGISTER:
{
ATOMID idApp = HszToAtom(hsz2);
UnwindProtect(cleanup6);
requests++;
if (idApp)
{
WORD wType;
OBJECTID idService = KppGetObjectId(idApp, &wType);
if (!idService)
{
idService = KppMakeCO(OBJECT, idApp, idDDEService);
wType = OBJECT;
}
if (idService)
{
if (DdeQueryString(dwDDEInst, hsz1, return_buffer,
RET_BUFFER_LEN, CP_WINANSI))
Kpp_Set_SlotValue(wType, idService, Slot(idService),
KppAddAtom(return_buffer), EXPATOM);
else
Kpp_Set_SlotValue(wType, idService, Slot(idService),
lpIDs->idNull, EXPATOM);
}
}
cleanup6:
requests--;
EndProtect();
return (HDDEDATA) NULL;
}
case XTYP_ADVDATA:
UnwindProtect(cleanup7);
requests++;
if (wFmt == CF_TEXT)
{
CONVINFO ci;
ATOMID idApp, idItem, idName;
OBJECTID idLink;
memset(&ci, 0, sizeof(CONVINFO));
ci.cb = sizeof(CONVINFO);
DdeQueryConvInfo(hConv, QID_SYNC, &ci);
idApp = HszToAtom(ci.hszSvcPartner);
idItem = HszToAtom(hsz2);
idName = LinkName(idApp, idItem);
idLink = FindLink(idName);
if (idLink)
{
WORD wDestType;
ATOMID idDest = Kpp_Get_SlotValue(OBJECT, idLink,
Slot(idDDEObject));
ATOMID idSlot = Kpp_Get_SlotValue(OBJECT, idLink,
Slot(idDDESlot));
OBJECTID idDestObj = KppGetObjectId(idDest, &wDestType);
StoreData(lpIDs->idNull, hData, idDestObj, idSlot);
}
}
cleanup7:
requests--;
EndProtect();
return (HDDEDATA) DDE_FACK;
case XTYP_XACT_COMPLETE:
{
char name[20];
OBJECTID idTask;
ATOMID idName;
WORD wType;
UnwindProtect(cleanup8);
requests++;
task_name(name, hConv, dwData1);
idName = KppAddAtom(name);
idTask = KppGetObjectId(idName, &wType);
if (idTask)
{
CONVINFO ci;
memset(&ci, 0, sizeof(CONVINFO));
ci.cb = sizeof(CONVINFO);
DdeQueryConvInfo(hConv, dwData1, &ci);
switch (ci.wType) {
case XTYP_REQUEST:
if (wFmt == CF_TEXT)
{
WORD wDestType;
ATOMID idDest = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDEObject));
ATOMID idSlot = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDESlot));
OBJECTID idDestObj = KppGetObjectId(idDest,
&wDestType);
StoreData(lpIDs->idNull, hData, idDestObj, idSlot);
DdeDisconnect(hConv);
}
break;
case XTYP_POKE:
case XTYP_EXECUTE:
DdeDisconnect(hConv);
break;
case (XTYP_ADVSTART | XTYPF_ACKREQ):
{
ATOMID idDest =
Kpp_Get_SlotValue(wType, idTask, Slot(idDDEObject));
WORD wDestType;
DDEINFO ddeInfo;
ddeInfo.hConv = hConv;
ddeInfo.idApp = Kpp_Get_SlotValue(wType, idTask,
Slot(idService));
ddeInfo.idTopic = Kpp_Get_SlotValue(wType, idTask,
Slot(idTopic));
ddeInfo.idItem = Kpp_Get_SlotValue(wType, idTask,
Slot(idItem));
ddeInfo.idObj = KppGetObjectId(idDest, &wDestType);
ddeInfo.idSlot = Kpp_Get_SlotValue(wType, idTask,
Slot(idDDESlot));
CreateLink(&ddeInfo);
break;
}
}
DeleteDDETask(lpIDs->idNull, wType, idTask, (LPVOID) &hConv);
}
cleanup8:
requests--;
EndProtect();
return (HDDEDATA) NULL;
}
default:
return (HDDEDATA) NULL;
}
}
static gboolean
run_task (RBMtpThread *thread, RBMtpThreadTask *task)
{
char *name = task_name (task);
rb_debug ("running task: %s", name);
g_free (name);
switch (task->task) {
case OPEN_DEVICE:
open_device (thread, task);
break;
case CLOSE_DEVICE:
return TRUE;
case SET_DEVICE_NAME:
if (LIBMTP_Set_Friendlyname (thread->device, task->name)) {
rb_mtp_thread_report_errors (thread, TRUE);
}
break;
case THREAD_CALLBACK:
{
RBMtpThreadCallback cb = (RBMtpThreadCallback)task->callback;
cb (thread->device, task->user_data);
}
break;
case ADD_TO_ALBUM:
add_track_to_album_and_update (thread, task);
break;
case REMOVE_FROM_ALBUM:
remove_track_from_album (thread, task);
break;
case SET_ALBUM_IMAGE:
set_album_image (thread, task);
break;
case GET_TRACK_LIST:
get_track_list (thread, task);
break;
case DELETE_TRACK:
if (LIBMTP_Delete_Object (thread->device, task->track_id)) {
rb_mtp_thread_report_errors (thread, TRUE);
}
break;
case UPLOAD_TRACK:
upload_track (thread, task);
break;
case DOWNLOAD_TRACK:
download_track (thread, task);
break;
default:
g_assert_not_reached ();
}
return FALSE;
}