void dftreal_loopy( const int dftsize, const double * xreal_in, double* X_out )
{
int k, n;
double TWO_PI = 2 * getPI();
double * one_out = X_out;
for (k = 0; k < dftsize; k++)
{
double ratio = -(TWO_PI * k) / dftsize;
double real = 0;
double imag = 0;
for (n = 0; n < dftsize; n++)
{
double x_n = xreal_in[ n ];
double angle = ratio * n;
real += x_n * cos( angle );
imag += x_n * sin( angle );
}
(*one_out) = real;
one_out++;
(*one_out) = imag;
one_out++;
}
}
int _tmain(int argc, _TCHAR* argv[])
{
int maxdigit = std::atoi(argv[1]);
if (maxdigit <= 0)
return 0;
SmallNum::setmaxdigit(maxdigit);
int start = clock();
SmallNum pi = getPI();
int end = clock();
pi.output(stdout);
printf("\n\n%f seconds\n", float(end - start) / CLOCKS_PER_SEC);
//system("pause");
return 0;
}
/* access a cache, perform a CMD operation on cache CP at address ADDR,
places NBYTES of data at *P, returns latency of operation if initiated
at NOW, places pointer to block user data in *UDATA, *P is untouched if
cache blocks are not allocated (!CP->BALLOC), UDATA should be NULL if no
user data is attached to blocks */
unsigned int /* latency of access in cycles */
cache_access(struct cache_t *cp, /* cache to access */
enum mem_cmd cmd, /* access type, Read or Write */
md_addr_t addr, /* address of access */
void *vp, /* ptr to buffer for input/output */
int nbytes, /* number of bytes to access */
tick_t now, /* time of access */
byte_t **udata, /* for return of user data ptr */
md_addr_t *repl_addr) /* for address of replaced block */
{
byte_t *p = vp;
md_addr_t tag = CACHE_TAG(cp, addr);
md_addr_t set = CACHE_SET(cp, addr);
md_addr_t bofs = CACHE_BLK(cp, addr);
/*
char t[50];
sprintf(t,"addr:%d tag:%d set:%d bofs:%d",addr,tag,set,bofs);
fatal(t);
//*/
////----mod
int pi=getPI(cp,addr);
////------ mod
struct cache_blk_t *blk, *repl;
int lat = 0;
/* default replacement address */
if (repl_addr)
*repl_addr = 0;
/* check alignments */
if ((nbytes & (nbytes-1)) != 0 || (addr & (nbytes-1)) != 0)
fatal("cache: access error: bad size or alignment, addr 0x%08x", addr);
/* access must fit in cache block */
/* FIXME:
((addr + (nbytes - 1)) > ((addr & ~cp->blk_mask) + (cp->bsize - 1))) */
if ((addr + nbytes) > ((addr & ~cp->blk_mask) + cp->bsize))
fatal("cache: access error: access spans block, addr 0x%08x", addr);
/* permissions are checked on cache misses */
/* check for a fast hit: access to same block */
if (CACHE_TAGSET(cp, addr) == cp->last_tagset)
{
/* hit in the same block */
blk = cp->last_blk;
goto cache_fast_hit;
}
if (cp->hsize)
{
/* higly-associativity cache, access through the per-set hash tables */
int hindex = CACHE_HASH(cp, tag);
for (blk=cp->sets[set].hash[hindex];
blk;
blk=blk->hash_next)
{
if (blk->tag == tag && (blk->status & CACHE_BLK_VALID))
goto cache_hit;
}
}
else
{
pi=11;
if(pi== 11 || pi== 00){//look at all
/* low-associativity cache, linear search the way list */
for (blk=cp->sets[set].way_head;
blk;
blk=blk->way_next)
{
if (blk->tag == tag && (blk->status & CACHE_BLK_VALID))
goto cache_hit;
}
}else if(pi==10){//look at thefirst half
}else{//look at the last half
}
}
/* cache block not found */
/* **MISS** */
cp->misses++;
/* select the appropriate block to replace, and re-link this entry to
the appropriate place in the way list */
switch (cp->policy) {
case LRU:
case FIFO:
repl = cp->sets[set].way_tail;
update_way_list(&cp->sets[set], repl, Head);
break;
case Random:
{
int bindex = myrand() & (cp->assoc - 1);
repl = CACHE_BINDEX(cp, cp->sets[set].blks, bindex);
}
break;
default:
panic("bogus replacement policy");
}
/* remove this block from the hash bucket chain, if hash exists */
if (cp->hsize)
unlink_htab_ent(cp, &cp->sets[set], repl);
/* blow away the last block to hit */
cp->last_tagset = 0;
cp->last_blk = NULL;
/* write back replaced block data */
if (repl->status & CACHE_BLK_VALID)
{
cp->replacements++;
if (repl_addr)
*repl_addr = CACHE_MK_BADDR(cp, repl->tag, set);
/* don't replace the block until outstanding misses are satisfied */
lat += BOUND_POS(repl->ready - now);
/* stall until the bus to next level of memory is available */
lat += BOUND_POS(cp->bus_free - (now + lat));
/* track bus resource usage */
cp->bus_free = MAX(cp->bus_free, (now + lat)) + 1;
if (repl->status & CACHE_BLK_DIRTY)
{
/* write back the cache block */
cp->writebacks++;
lat += cp->blk_access_fn(Write,
CACHE_MK_BADDR(cp, repl->tag, set),
cp->bsize, repl, now+lat);
}
}
/* update block tags */
repl->tag = tag;
repl->status = CACHE_BLK_VALID; /* dirty bit set on update */
/* read data block */
lat += cp->blk_access_fn(Read, CACHE_BADDR(cp, addr), cp->bsize,
repl, now+lat);
/* copy data out of cache block */
if (cp->balloc)
{
CACHE_BCOPY(cmd, repl, bofs, p, nbytes);
}
/* update dirty status */
if (cmd == Write)
repl->status |= CACHE_BLK_DIRTY;
/* get user block data, if requested and it exists */
if (udata)
*udata = repl->user_data;
/* update block status */
repl->ready = now+lat;
/* link this entry back into the hash table */
if (cp->hsize)
link_htab_ent(cp, &cp->sets[set], repl);
/* return latency of the operation */
return lat;
cache_hit: /* slow hit handler */
/* **HIT** */
cp->hits++;
/* copy data out of cache block, if block exists */
if (cp->balloc)
{
CACHE_BCOPY(cmd, blk, bofs, p, nbytes);
}
/* update dirty status */
if (cmd == Write)
blk->status |= CACHE_BLK_DIRTY;
/* if LRU replacement and this is not the first element of list, reorder */
if (blk->way_prev && cp->policy == LRU)
{
/* move this block to head of the way (MRU) list */
update_way_list(&cp->sets[set], blk, Head);
}
/* tag is unchanged, so hash links (if they exist) are still valid */
/* record the last block to hit */
cp->last_tagset = CACHE_TAGSET(cp, addr);
cp->last_blk = blk;
/* get user block data, if requested and it exists */
if (udata)
*udata = blk->user_data;
/* return first cycle data is available to access */
return (int) MAX(cp->hit_latency, (blk->ready - now));
cache_fast_hit: /* fast hit handler */
/* **FAST HIT** */
cp->hits++;
/* copy data out of cache block, if block exists */
if (cp->balloc)
{
CACHE_BCOPY(cmd, blk, bofs, p, nbytes);
}
/* update dirty status */
if (cmd == Write)
blk->status |= CACHE_BLK_DIRTY;
/* this block hit last, no change in the way list */
/* tag is unchanged, so hash links (if they exist) are still valid */
/* get user block data, if requested and it exists */
if (udata)
*udata = blk->user_data;
/* record the last block to hit */
cp->last_tagset = CACHE_TAGSET(cp, addr);
cp->last_blk = blk;
/* return first cycle data is available to access */
return (int) MAX(cp->hit_latency, (blk->ready - now));
}
