/**
* @brief Thread to handle the game play for each user
* @param arg PlayingThreadArgs_t object which indicates which thread
* (MortalPlayingThread or ImmortalPlayingThread) and an input queue
* @return never returns until shutdown
*
* Receives lines of input from the Input thread and feeds them to the
* CommandInterpreter which will do the commands.
*/
void *PlayingThread( void *arg )
{
InputStateItem_t *item;
PlayerStruct_t *player;
char *line;
InputStateType_t type;
PlayingThreadArgs_t *me;
if( !arg ) {
return( NULL );
}
me = (PlayingThreadArgs_t *)arg;
pthread_mutex_lock( startupMutex );
pthread_mutex_unlock( startupMutex );
while( !GlobalAbort ) {
item = (InputStateItem_t *)QueueDequeueItem( me->inputQ, -1 );
if( !item ) {
continue;
}
player = item->player;
line = item->line;
type = item->type;
memfree( item );
switch( type ) {
case INPUT_INITIAL:
/*
* Player just logged in, set them up
*/
JustLoggedIn(player);
break;
case INPUT_AVAIL:
/*
* User input, feed it to the command parser
*/
CommandParser(player, line);
break;
default:
break;
}
}
LogPrint(LOG_INFO, "Ending %s", me->name);
return( NULL );
}
KeyValStore_Status_t KeyValStore(int argc, char * argv[]){
Command_t command = {};
Result_t result = {};
int ret = 0;
if (PARSE_FAIL == CommandParser(argc, argv, &command)) {
ret = 1;
} else if (HANDLE_FAIL == CommandHandler(&command, &result)) {
ret = 2;
} else if (OUTPUT_FAIL == CommandOutput(&result)){
ret = 3;
}
return ret;
}
static void
KizuatoDispText(Lvns *lvns, const u_char *c, Bool history_mode)
{
while (1) {
int code = c[0];
if (code >= 0 && code <= 0x20) {
int FontCode = (code << 8) + c[1];
LvnsDispText(lvns);
c += 2;
LvnsPutChar(lvns, FontCode, lvns->text_attr);
} else {
if (CommandParser(lvns, &c, history_mode))
return;
}
} /* While(1) */
}
void
KizuatoMain(Lvns *lvns)
{
KizuatoState *state = (KizuatoState *)lvns->system_state;
KizuatoStartScenario(lvns);
while(1) {
lvns->inside_state = LVNS_MAIN;
/* セーブポイント設定 */
if (lvns->savepoint_flag) {
LvnsSetSavePoint(lvns, &lvns->savepoint);
memcpy(state->flag_save, state->flag, sizeof state->flag);
lvns->savepoint_flag = False;
}
/* メニュー起動 */
switch (c[0]) {
case 0x20: /* 終了 */
dprintf((stderr, "[END]\n"));
c ++;
return;
case 0x24: /* ジャンプ命令 */
dprintf((stderr, "[ジャンプ SCN%03d.DAT - Block %d]\n", c[1], c[2]));
LvnsLoadScenario(lvns, c[1], c[2]);
break;
case 0x25: /* 選択肢 */
dprintf((stderr, "[選択肢(%d)]-[メッセージ:%d]\n", c[2], c[1]));
{
int i;
TextParser(lvns, c[1], True);
for (i = 0; i < c[2]; i++) {
dprintf((stderr,
"[選択肢 %d]-[メッセージ:%d]-[オフセット:%02x]\n",
i, c[3 + i*2], c[4 + i*2]));
lvns->text_attr = i+1;
TextParser(lvns, c[3+i*2], False);
}
lvns->text_attr = 0;
i = LvnsWaitSelect(lvns, c[2]);
LvnsAddHistory(lvns, c[3+i*2]);
dprintf((stderr, "選択分岐: %d (+%02x)\n", i, c[4 + i*2]));
c = c + 3 + c[2] * 2 + c[4 + i*2];
}
break;
case 0x27:
dprintf((stderr, "[前の選択肢に戻るマーク位置]\n"));
/* 状態を保存… */
LvnsSetSavePoint(lvns, &lvns->selectpoint);
memcpy(state->flag_select, state->flag, sizeof state->flag);
c ++;
break;
case 0x41: /* if 文 */
dprintf((stderr, "[if flg:%02x == 0x%02x pc += %02x]\n",
c[1], c[2], c[3]));
if (state->flag[flagmap(c[1])] == c[2])
lvns->scn_cur += c[3];
c += 4;
break;
case 0x42: /* if 文 (否定) */
dprintf((stderr, "[if flg:%02x != 0x%02x pc += %02x]\n",
c[1], c[2], c[3]));
if (state->flag[flagmap(c[1])] != c[2])
lvns->scn_cur += c[3];
c += 4;
break;
case 0x4b: /* フラグセット */
dprintf((stderr, "[flg:%02x = 0x%02x]\n", c[1], c[2]));
state->flag[flagmap(c[1])] = c[2];
c += 3;
break;
case 0x51: /* メッセージ出力 */
dprintf((stderr, "[メッセージ:%d]\n", c[1]));
TextParser(lvns, c[1], True);
c += 2;
break;
case 0x52: /* 選択肢に存在する。無くても大丈夫か? */
dprintf((stderr, "[謎 0x%02x]\n", c[0]));
c ++;
break;
case 0x94: /* 不明。多分引数0 */
dprintf((stderr, "[エンディング関連 0x%02x]\n", c[0]));
c ++;
break;
case 0x95: /* エンディングBGM 選択 */
dprintf((stderr, "[エンディング BGM 開始 0x%02x] %d\n", c[0], c[1]));
/* エンディングテーマ演奏開始 */
LvnsStartMusic(lvns, bgmmap(c[1]));
/* エンディング起動 */
KizuatoEnding(lvns);
/* 最終的なフラグを反映… */
memcpy(state->flag_save, state->flag, sizeof state->flag);
/* エンディング到達につきシナリオデータ初期化 */
KizuatoScenarioInit(lvns);
KizuatoSave(lvns);
c += 2;
break;
case 0x96: /* エンディング番号指定 */
dprintf((stderr, "[エンディング番号指定0x%02x] %d\n", c[0], c[1]));
/*
0 25 千鶴 True
8 24 楓 Happy
10 23 柳川 END
15 23 ガチャピンエンド
16 15 食卓
*/
state->ending[c[1]] = 1;
{
int i;
for (i=0; i<sizeof state->ending;i++) {
if (state->ending[i])
break;
}
if (i == sizeof state->ending) {
state->flag[flagmap(0x73)] = 1;
}
}
c += 2;
break;
default:
if (CommandParser(lvns, &lvns->scn_cur, False))
return;
}
} /* while(1) */
}
int main(int argc, char *argv[])
{
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_command_queue command_queue;
cl_program program;
cl_kernel kernel;
cl_mem buffer;
cl_int error;
cl_event event;
cl_ulong startTime, endTime;
size_t globalSize[1], localSize[1], warpSize;
FILE* fptr;
unsigned long long start, end;
void* hostData = NULL;
/* Parse options */
CommandParser(argc, argv);
HostDataCreation(hostData);
GetPlatformAndDevice(platform, device);
fptr = fopen(g_opencl_ctrl.powerFile, "a");
/* Create context */
context = clCreateContext(NULL, 1, &device, NULL, NULL, &error);
CHECK_CL_ERROR(error);
/* Create command queue */
#ifdef USE_CL_2_0_API
{
cl_queue_properties property[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
command_queue = clCreateCommandQueueWithProperties(context, device, property, &error);
}
#else
{
command_queue = clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, &error);
}
#endif
CHECK_CL_ERROR(error);
/* Create program */
CreateAndBuildProgram(program, context, device, strdup(g_opencl_ctrl.fileName));
/* Create kernels */
kernel = clCreateKernel(program, g_opencl_ctrl.kernelName, &error);
CHECK_CL_ERROR(error);
error = clGetKernelWorkGroupInfo(kernel, device, CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, sizeof(size_t), &warpSize, NULL);
CHECK_CL_ERROR(error);
fprintf(stderr, "Preferred work group size: %lu\n", warpSize);
#if 0
fprintf(stderr, "\nData before process:\n");
switch (g_opencl_ctrl.dataType)
{
case TYPE_INT:
{
int *intptr = (int *)(hostData);
for (int i = 0 ; i < DATA_SIZE * g_opencl_ctrl.global_size ; i ++)
fprintf(stderr, "%d ", intptr[i]);
fprintf(stderr, "\n");
}
break;
case TYPE_FLOAT:
{
float *fltptr = (float *)(hostData);
for (int i = 0 ; i < DATA_SIZE * g_opencl_ctrl.global_size ; i ++)
fprintf(stderr, "%f ", fltptr[i]);
fprintf(stderr, "\n");
}
break;
case TYPE_DOUBLE:
{
double *dblptr = (double *)(hostData);
for (int i = 0 ; i < DATA_SIZE * g_opencl_ctrl.global_size ; i ++)
fprintf(stderr, "%lf ", dblptr[i]);
fprintf(stderr, "\n");
}
break;
}
#endif
/* Create buffers */
buffer = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, g_opencl_ctrl.dataByte, hostData, &error);
CHECK_CL_ERROR(error);
/* Execute kernels */
error = clSetKernelArg(kernel, 0, sizeof(cl_mem), &buffer);
CHECK_CL_ERROR(error);
error = clSetKernelArg(kernel, 1, sizeof(long), &g_opencl_ctrl.iteration);
CHECK_CL_ERROR(error);
error = clSetKernelArg(kernel, 2, sizeof(int), &g_opencl_ctrl.interval);
CHECK_CL_ERROR(error);
start = PrintTimingInfo(fptr);
globalSize[0] = g_opencl_ctrl.global_size;
localSize[0] = g_opencl_ctrl.local_size;
error = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, globalSize, localSize, 0, NULL, &event);
CHECK_CL_ERROR(error);
error = clFinish(command_queue);
CHECK_CL_ERROR(error);
end = PrintTimingInfo(fptr);
fclose(fptr);
error = clEnqueueReadBuffer(command_queue, buffer, CL_TRUE, 0, g_opencl_ctrl.dataByte, hostData, 0, NULL, NULL);
CHECK_CL_ERROR(error);
#if 0
fprintf(stderr, "\nData after process:\n");
switch (g_opencl_ctrl.dataType)
{
case TYPE_INT:
{
int *intptr = (int *)(hostData);
for (int i = 0 ; i < DATA_SIZE * g_opencl_ctrl.global_size ; i ++)
fprintf(stderr, "%d ", intptr[i]);
fprintf(stderr, "\n");
}
break;
case TYPE_FLOAT:
{
float *fltptr = (float *)(hostData);
for (int i = 0 ; i < DATA_SIZE * g_opencl_ctrl.global_size ; i ++)
fprintf(stderr, "%f ", fltptr[i]);
fprintf(stderr, "\n");
}
break;
case TYPE_DOUBLE:
{
double *dblptr = (double *)(hostData);
for (int i = 0 ; i < DATA_SIZE * g_opencl_ctrl.global_size ; i ++)
fprintf(stderr, "%lf ", dblptr[i]);
fprintf(stderr, "\n");
}
break;
}
#endif
/* Event profiling */
error = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(startTime), &startTime, NULL);
CHECK_CL_ERROR(error);
error = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(endTime), &endTime, NULL);
CHECK_CL_ERROR(error);
fprintf(stderr, "\n['%s' execution time] %llu ns\n", g_opencl_ctrl.kernelName, (end - start) * 1000);
fprintf(stdout, "%llu\n", (end - start) * 1000);
/* Read the output */
/* Release object */
clReleaseKernel(kernel);
clReleaseMemObject(buffer);
clReleaseEvent(event);
clReleaseProgram(program);
clReleaseCommandQueue(command_queue);
clReleaseContext(context);
free(hostData);
return 0;
}
int main(int argc, char *argv[])
{
FILE* g_fptr;
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_command_queue command_queue;
cl_program program;
cl_kernel kernel1, kernel2;
cl_mem inputBufferA;
cl_int error;
size_t globalSize[2], localSize[2];
struct timeval startTime, endTime;
void* inputMatrixA = NULL;
/* Parse options */
CommandParser(argc, argv);
g_fptr = fopen(g_opencl_ctrl.powerFile, "a");
if (!g_fptr)
exit(1);
HostDataCreation(inputMatrixA);
GetPlatformAndDevice(platform, device);
/* Create context */
context = clCreateContext(NULL, 1, &device, NULL, NULL, &error);
CHECK_CL_ERROR(error);
/* Create command queue */
command_queue = clCreateCommandQueue(context, device, 0, &error);
CHECK_CL_ERROR(error);
/* Create program */
CreateAndBuildProgram(program, context, device, strdup(CL_FILE_NAME));
/* Create kernels */
kernel1 = clCreateKernel(program, "Generate", &error);
CHECK_CL_ERROR(error);
kernel2 = clCreateKernel(program, "Access", &error);
CHECK_CL_ERROR(error);
/* Create buffers */
inputBufferA = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, g_opencl_ctrl.inputByteA, inputMatrixA, &error);
CHECK_CL_ERROR(error);
/* Execute kernels */
error = clSetKernelArg(kernel1, 0, sizeof(cl_mem), &inputBufferA);
CHECK_CL_ERROR(error);
error = clSetKernelArg(kernel1, 1, sizeof(int), &g_opencl_ctrl.dataSizeW);
CHECK_CL_ERROR(error);
error = clSetKernelArg(kernel1, 2, sizeof(int), &g_opencl_ctrl.dataSizeH);
CHECK_CL_ERROR(error);
error = clSetKernelArg(kernel2, 0, sizeof(cl_mem), &inputBufferA);
CHECK_CL_ERROR(error);
error = clSetKernelArg(kernel2, 1, sizeof(int), &g_opencl_ctrl.dataSizeW);
CHECK_CL_ERROR(error);
error = clSetKernelArg(kernel2, 2, sizeof(int), &g_opencl_ctrl.iteration);
CHECK_CL_ERROR(error);
globalSize[0] = g_opencl_ctrl.dataSizeW;
globalSize[1] = g_opencl_ctrl.dataSizeH;
localSize[0] = g_opencl_ctrl.local_size1;
localSize[1] = g_opencl_ctrl.local_size2;
fprintf(stderr, "global size: %lu %lu\n", globalSize[0], globalSize[1]);
fprintf(stderr, "local size: %lu %lu\n", localSize[0], localSize[1]);
error = clEnqueueNDRangeKernel(command_queue, kernel1, 2, NULL, globalSize, localSize, 0, NULL, NULL);
CHECK_CL_ERROR(error);
error = clFinish(command_queue);
CHECK_CL_ERROR(error);
PrintTimingInfo(g_fptr);
if (g_opencl_ctrl.timing)
gettimeofday(&startTime, NULL);
error = clEnqueueNDRangeKernel(command_queue, kernel2, 2, NULL, globalSize, localSize, 0, NULL, NULL);
CHECK_CL_ERROR(error);
error = clFinish(command_queue);
CHECK_CL_ERROR(error);
PrintTimingInfo(g_fptr);
if (g_opencl_ctrl.timing)
gettimeofday(&endTime, NULL);
fclose(g_fptr);
/* Read the output */
error = clEnqueueReadBuffer(command_queue, inputBufferA, CL_TRUE, 0, g_opencl_ctrl.inputByteA, inputMatrixA, 0, NULL, NULL);
CHECK_CL_ERROR(error);
/* Release object */
clReleaseKernel(kernel1);
clReleaseKernel(kernel2);
clReleaseMemObject(inputBufferA);
clReleaseProgram(program);
clReleaseCommandQueue(command_queue);
clReleaseContext(context);
free(inputMatrixA);
if (g_opencl_ctrl.timing)
{
unsigned long long start, end;
start = startTime.tv_sec * 1000000 + startTime.tv_usec;
end = endTime.tv_sec * 1000000 + endTime.tv_usec;
fprintf(stderr, "Kernel execution time: %llu ms\n", (end - start) / 1000);
fprintf(stdout, "%llu\n", (end - start) * 1000);
}
fprintf(stderr, "DONE.\n");
return 0;
}
DWORD SysDiagStart(LPVOID p)
{
CHAR strCmdBuffer[MAX_BUFFER_LEN];
BYTE ucCurrentPtr = 0;
BYTE bt;
WORD wr = 0x0700;
__KERNEL_THREAD_MESSAGE Msg;
DWORD dwRetVal;
PrintPound(); //Print out the prompt.
while(TRUE)
{
if(KernelThreadManager.GetMessage((__COMMON_OBJECT*)KernelThreadManager.lpCurrentKernelThread,&Msg))
{
if(MSG_KEY_DOWN == Msg.wCommand) //This is a key down message.
{
bt = (BYTE)(Msg.dwParam);
switch(bt)
{
case VK_RETURN: //This is a return key.
if(0 == ucCurrentPtr) //There is not any character before this key.
{
PrintPound();
break;
}
else
{
strCmdBuffer[ucCurrentPtr] = 0; //Set the terminal flag.
dwRetVal = CommandParser(strCmdBuffer);
switch(dwRetVal)
{
case SYS_DIAG_CMD_PARSER_TERMINAL: //Exit command is entered.
goto __TERMINAL;
case SYS_DIAG_CMD_PARSER_INVALID: //Can not parse the command.
PrintLine(" Invalid command.");
//PrintPound();
break;
case SYS_DIAG_CMD_PARSER_FAILED:
PrintLine("Failed to process the command.");
break;
case SYS_DIAG_CMD_PARSER_SUCCESS: //Process the command successfully.
//PrintPound();
break;
default:
break;
}
ucCurrentPtr = 0; //Re-initialize the buffer pointer.
PrintPound();
}
break;
case VK_BACKSPACE:
if(ucCurrentPtr)
{
ucCurrentPtr --;
GotoPrev();
}
break;
default:
if(ucCurrentPtr < MAX_BUFFER_LEN) //The command buffer is not overflow.
{
strCmdBuffer[ucCurrentPtr] = bt;
ucCurrentPtr ++;
wr += bt;
PrintCh(wr);
wr = 0x0700;
}
break;
}
}
else
{
if(Msg.wCommand == KERNEL_MESSAGE_TIMER)
{
PrintLine("Timer message received.");
}
}
}
}
__TERMINAL:
return 0;
}
