hsa_status_t HSA_API
hsa_amd_profiling_get_dispatch_time(hsa_agent_t agent_handle,
hsa_signal_t hsa_signal,
hsa_amd_profiling_dispatch_time_t* time) {
IS_OPEN();
IS_BAD_PTR(time);
core::Agent* agent = core::Agent::Convert(agent_handle);
IS_VALID(agent);
core::Signal* signal = core::Signal::Convert(hsa_signal);
IS_VALID(signal);
if (agent->device_type() != core::Agent::kAmdGpuDevice) {
return HSA_STATUS_ERROR_INVALID_AGENT;
}
amd::GpuAgentInt* gpu_agent = static_cast<amd::GpuAgentInt*>(agent);
gpu_agent->TranslateTime(signal, *time);
return HSA_STATUS_SUCCESS;
}
SQLRETURN SQL_API SQLNativeSql(SQLHDBC ConnectionHandle,
SQLCHAR * InStatementText,
SQLINTEGER TextLength1,
SQLCHAR * OutStatementText,
SQLINTEGER BufferLength,
SQLINTEGER * TextLength2Ptr)
{
hDbc_T *dbc = (hDbc_T *) ConnectionHandle;
SQLRETURN status = SQL_SUCCESS;
if (ENABLE_TRACE) {
ood_log_message(dbc, __FILE__, __LINE__, TRACE_FUNCTION_ENTRY,
(SQLHANDLE) dbc, 0, "");
}
ood_clear_diag((hgeneric *) dbc);
THREAD_MUTEX_LOCK(dbc);
THREAD_MUTEX_UNLOCK(dbc);
if (ENABLE_TRACE) {
ood_log_message(dbc, __FILE__, __LINE__, TRACE_FUNCTION_EXIT,
(SQLHANDLE) NULL, status, "");
}
fprintf(stderr, "called stubbed function line %d file %s\n", __LINE__,
__FILE__);
assert(IS_VALID(dbc));
return SQL_SUCCESS;
}
void free_pcdata(PC_DATA *pcdata)
{
int alias;
if (!IS_VALID(pcdata))
return;
free_string(pcdata->pwd);
free_string(pcdata->bamfin);
free_string(pcdata->bamfout);
free_string(pcdata->invisin);
free_string(pcdata->invisout);
free_string(pcdata->who_descr);
free_string(pcdata->title);
free_buf(pcdata->buffer);
for (alias = 0; alias < MAX_ALIAS; alias++)
{
free_string(pcdata->alias[alias]);
free_string(pcdata->alias_sub[alias]);
}
for (alias = 0; alias < MAX_FORGET; alias++)
{
free_string(pcdata->forget[alias]);
}
for (alias = 0; alias < MAX_DUPES; alias++)
{
free_string(pcdata->dupes[alias]);
}
INVALIDATE(pcdata);
pcdata->next = pcdata_free;
pcdata_free = pcdata;
return;
}
void free_obj( OBJ_DATA *obj )
{
AFFECT_DATA *paf, *paf_next;
EXTRA_DESCR_DATA *ed, *ed_next;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
if ( !IS_VALID(obj) )
return;
for ( paf = obj->affected; paf != NULL; paf = paf_next )
{
paf_next = paf->next;
free_affect( paf );
}
obj->affected = NULL;
for ( ed = obj->extra_descr; ed != NULL; ed = ed_next )
{
ed_next = ed->next;
free_extra_descr( ed );
}
obj->extra_descr = NULL;
free_string( obj->name );
free_string( obj->description );
free_string( obj->short_descr );
free_string( obj->owner );
INVALIDATE( obj );
obj->next = obj_free;
obj_free = obj;
}
hsa_status_t HSA_API hsa_amd_coherency_set_type(hsa_agent_t agent_handle,
hsa_amd_coherency_type_t type) {
IS_OPEN();
core::Agent* agent = core::Agent::Convert(agent_handle);
IS_VALID(agent);
if (type < HSA_AMD_COHERENCY_TYPE_COHERENT ||
type > HSA_AMD_COHERENCY_TYPE_NONCOHERENT) {
return HSA_STATUS_ERROR_INVALID_ARGUMENT;
}
if (agent->device_type() != core::Agent::kAmdGpuDevice) {
return HSA_STATUS_ERROR_INVALID_AGENT;
}
amd::GpuAgent* gpu_agent = static_cast<amd::GpuAgent*>(agent);
if (!gpu_agent->current_coherency_type(type)) {
return HSA_STATUS_ERROR;
}
return HSA_STATUS_SUCCESS;
}
void free_pcdata(PC_DATA *pcdata)
{
int alias;
if (!IS_VALID(pcdata))
return;
free_string(pcdata->pwd);
free_string(pcdata->bamfin);
free_string(pcdata->bamfout);
free_string(pcdata->roomin);
free_string(pcdata->roomout);
free_string(pcdata->wiziin); /* Ferg-wizicust */
free_string(pcdata->wiziout); /* Ferg-wizicust */
free_string(pcdata->title);
free_buf(pcdata->buffer);
for (alias = 0; alias < MAX_ALIAS; alias++)
{
free_string(pcdata->alias[alias]);
free_string(pcdata->alias_sub[alias]);
}
INVALIDATE(pcdata);
pcdata->next = pcdata_free;
pcdata_free = pcdata;
return;
}
void free_storer_data( ARTEFACT_STORER *storer )
{
if ( !IS_VALID( storer ) ) return ;
INVALIDATE( storer );
storer->next = storer_free;
storer_free = storer;
}
/*
** Write_Cache - this writes a word to the cache, and also writes
** the value out to memory.
*/
void Write_Cache(unsigned long int address, unsigned long int data){
int i;
unsigned long int word;
unsigned long int tag;
unsigned long int set;
unsigned long int cache_line;
tag = address & TAG_MASK;
word = address & WORD_MASK;
set = address & SET_MASK;
cache_line = set >> SET_SHIFT;
if( (tags[cache_line] == tag) && (IS_VALID(cache_line)) ){
cache_hits++;
LRU_Access(cache_line);
rammem[set + tag + word] = cache[cache_line][word] = data;
}
else {
cache_misses++;
for(i = 0; i < NUM_WORDS_PER_LINE; i++){
cache[cache_line][i] = rammem[tag + set + i];
}
tags[cache_line] = tag;
LRU_Access(cache_line);
rammem[set + tag + word] = cache[cache_line][word] = data;
}
}
void free_pcdata(PC_DATA *pcdata)
{
int alias;
GRANT_DATA *gran,*gran_next;
if (!IS_VALID(pcdata))
return;
free_string(pcdata->pwd);
free_string(pcdata->bamfin);
free_string(pcdata->bamfout);
free_string(pcdata->title);
free_buf(pcdata->buffer);
for (gran = pcdata->granted; gran != NULL; gran = gran_next)
{
gran_next = gran->next;
free_string(gran->name);
free_mem(gran,sizeof(*gran));
}
for (alias = 0; alias < MAX_ALIAS; alias++)
{
free_string(pcdata->alias[alias]);
free_string(pcdata->alias_sub[alias]);
}
INVALIDATE(pcdata);
pcdata->next = pcdata_free;
pcdata_free = pcdata;
return;
}
void free_sleep_data(SLEEP_DATA *sd)
{
if (!IS_VALID(sd))
return;
INVALIDATE(sd);
sd->next = sd_free;
sd_free = sd;
}
void free_mprog(MPROG_LIST *mp)
{
if (!IS_VALID(mp))
return;
INVALIDATE(mp);
mp->next = mprog_free;
mprog_free = mp;
}
hsa_status_t HSA_API hsa_ext_set_profiling(hsa_queue_t* queue, int enable) {
core::Queue* cmd_queue = core::Queue::Convert(queue);
IS_VALID(cmd_queue);
cmd_queue->amd_queue_.enable_profiling = (enable != 0);
return HSA_STATUS_SUCCESS;
}
void free_rprog(PROG_LIST *rp)
{
if (!IS_VALID(rp))
return;
INVALIDATE(rp);
rp->next = rprog_free;
rprog_free = rp;
}
void free_oprog(PROG_LIST *op)
{
if (!IS_VALID(op))
return;
INVALIDATE(op);
op->next = oprog_free;
oprog_free = op;
}
void free_room_weave(AFFECT_DATA *wd)
{
if (!IS_VALID(wd))
return;
INVALIDATE(wd);
wd->next = room_weave_free;
room_weave_free = wd;
}
void free_residue(RESIDUE_DATA *rd)
{
if (!IS_VALID(rd))
return;
INVALIDATE(rd);
rd->next = residue_free;
residue_free = rd;
}
void free_mem_data(MEM_DATA *memory)
{
if (!IS_VALID(memory))
return;
memory->next = mem_data_free;
mem_data_free = memory;
INVALIDATE(memory);
}
void free_affect( AFFECT_DATA *af )
{
if ( !IS_VALID(af) )
return;
INVALIDATE( af );
af->next = affect_free;
affect_free = af;
}
void free_ward(WARD_DATA *wd)
{
if (!IS_VALID(wd))
return;
INVALIDATE(wd);
wd->next = ward_free;
ward_free = wd;
}
/**
* @brief Yields the processor.
*/
PUBLIC void yield(void)
{
struct process *p; /* Working process. */
struct process *next; /* Next process to run. */
/* Re-schedule process for execution. */
if (curr_proc->state == PROC_RUNNING)
sched(curr_proc);
/* Remember this process. */
last_proc = curr_proc;
/* Check alarm. */
for (p = FIRST_PROC; p <= LAST_PROC; p++)
{
/* Skip invalid processes. */
if (!IS_VALID(p))
continue;
/* Alarm has expired. */
if ((p->alarm) && (p->alarm < ticks))
p->alarm = 0, sndsig(p, SIGALRM);
}
/* Choose a process to run next. */
next = IDLE;
for (p = FIRST_PROC; p <= LAST_PROC; p++)
{
/* Skip non-ready process. */
if (p->state != PROC_READY)
continue;
/*
* Process with higher
* waiting time found.
*/
if (p->counter > next->counter)
{
next->counter++;
next = p;
}
/*
* Increment waiting
* time of process.
*/
else
p->counter++;
}
/* Switch to next process. */
next->priority = PRIO_USER;
next->state = PROC_RUNNING;
next->counter = PROC_QUANTUM;
switch_to(next);
}
void free_char (CHAR_DATA *ch)
{
OBJ_DATA *obj;
OBJ_DATA *obj_next;
AFFECT_DATA *paf;
AFFECT_DATA *paf_next;
if (!IS_VALID(ch))
return;
if (IS_NPC(ch))
mobile_count--;
for (obj = ch->carrying; obj != NULL; obj = obj_next)
{
obj_next = obj->next_content;
extract_obj(obj);
}
for (paf = ch->affected; paf != NULL; paf = paf_next)
{
paf_next = paf->next;
affect_remove(ch,paf);
}
free_string(ch->name);
free_string(ch->wkname);
free_string(ch->real_name);
free_string(ch->short_descr);
free_string(ch->long_descr);
free_string(ch->description);
free_string(ch->hood_description);
free_string(ch->veil_description);
free_string(ch->wolf_description);
free_string(ch->wound_description);
free_string(ch->aura_description);
free_string(ch->prompt);
free_string(ch->prefix);
free_string(ch->gtitle);
free_string(ch->sguild_title);
free_string(ch->tguild_title);
free_string(ch->mtitle);
free_string(ch->mname);
/* free_note (ch->pnote); */
free_pcdata(ch->pcdata);
ch->next = char_free;
char_free = ch;
INVALIDATE(ch);
return;
}
hsa_status_t HSA_API hsa_amd_queue_cu_set_mask(const hsa_queue_t* queue,
uint32_t num_cu_mask_count,
const uint32_t* cu_mask) {
IS_OPEN();
IS_BAD_PTR(cu_mask);
core::Queue* cmd_queue = core::Queue::Convert(queue);
IS_VALID(cmd_queue);
return cmd_queue->SetCUMasking(num_cu_mask_count, cu_mask);
}
void free_gen_data(GEN_DATA *gen)
{
if (!IS_VALID(gen))
return;
INVALIDATE(gen);
gen->next = gen_data_free;
gen_data_free = gen;
}
void free_event(EVENT_DATA *ev)
{
if (!IS_VALID(ev))
return;
INVALIDATE(ev);
ev->next = ev_free;
ev_free = ev;
}
/*
** Write_Cache - this writes a word to the cache, and also writes
** the value out to memory.
*/
void Write_Cache(unsigned long int address, unsigned long int data){
int i,j;
int invalid_line = -1;
int victim = 0;
unsigned long int word;
unsigned long int block;
block = address & TAG_MASK;
word = address & WORD_MASK;
for(i = 0; i < NUM_CACHE_LINES; i++){
if( !IS_VALID(i) ){
invalid_line = i;
}
else{
if(block == tags[i])
break;
}
}
if(i == NUM_CACHE_LINES){
/* cache miss -- find a victim */
cache_misses++;
if(invalid_line != -1){
for(j = 0; j < NUM_WORDS_PER_LINE; j++){
cache[invalid_line][j] = rammem[block + j];
}
tags[invalid_line] = block;
LRU_Access(invalid_line);
rammem[block + word] = data;
cache[invalid_line][word] = data;
}
else{
for(j = 0; j < NUM_CACHE_LINES; j++){
if(mem_count[j] > mem_count[victim]){
victim = j;
}
}
for(j = 0; j < NUM_WORDS_PER_LINE; j++){
cache[victim][j] = rammem[block + j];
}
tags[victim] = block;
LRU_Access(victim);
rammem[block + word] = data;
cache[victim][word] = data;
}
}
else{
/* cache hit - just write the puppy out */
cache_hits++;
LRU_Access(i);
rammem[block + word] = data;
cache[i][word] = data;
}
}
void free_wiz(WIZ_DATA *wiz)
{
if (!IS_VALID(wiz))
return;
free_string(wiz->name);
INVALIDATE(wiz);
wiz->next = wiz_free;
wiz_free = wiz;
}
void free_mbr(MBR_DATA *mbr)
{
if (!IS_VALID(mbr))
return;
free_string(mbr->name);
INVALIDATE(mbr);
mbr->next = mbr_free;
mbr_free = mbr;
}
void free_descriptor( DESCRIPTOR_DATA *d )
{
if ( !IS_VALID(d) )
return;
free_string( d->host );
free_mem( d->outbuf, d->outsize );
INVALIDATE( d );
d->next = descriptor_free;
descriptor_free = d;
}
void free_ban( BAN_DATA *ban )
{
if ( !IS_VALID(ban) )
return;
free_string( ban->name );
INVALIDATE( ban );
ban->next = ban_free;
ban_free = ban;
}
void free_extra_descr( EXTRA_DESCR_DATA *ed )
{
if ( !IS_VALID(ed) )
return;
free_string( ed->keyword );
free_string( ed->description );
INVALIDATE( ed );
ed->next = extra_descr_free;
extra_descr_free = ed;
}
