WORD xtermres(long blkln, WORD rc)
{
xsetblk(0,run,blkln);
reserve_block(run, find_mpb(run));
xterm(rc);
}
// Tensors must be sorted from most to least significant dimension.
// nc is the number of contracted indices, and
// ind is an array of (nx by 2) integers (pairs of contracted indices).
Tensor *tensdot(Tensor *a, Tensor *b, int nc, int *ind, int nref, Slice *m) {
int i = 0;
int ord_a, ord_b;
int *anum, *bnum;
int an, bn;
Tensor *t;
#ifdef PARANOID
if(nc > a->n || nc > b->n) {
fprintf(stderr, "tensdor: more contracted than input dims.\n");
exit(1);
}
#endif
anum = number_indices(a->n, nc, ind);
bnum = number_indices(b->n, nc, ind+1);
t = tensor_ctor(a->n + b->n - 2*nc);
an = copy_shape(a, anum, t->shape);
bn = copy_shape(b, bnum, t->shape + a->n - nc);
t->len = an*bn;
t->b = reserve_block(m, nref, t->len*sizeof(float));
if(nc == 0) { // trivial case A <- a X Y^T + A, A m x n
GER(bn, an, 1.0, b->b->x, 1, a->b->x, 1,
t->b->x, an);
//GER(bn, an, a->scale*b->scale, b->b->x, 1, a->b->x, 1,
// t->b->x, an);
free(anum); free(bnum);
return t;
}
if( (ord_a = ck_ordered(a->n, anum))) {
if( (ord_b = ck_ordered(b->n, bnum))
&& ck_same(nc, ind)) { // Straightforward dgemm.
GEMM(ord_b == 1, ord_a == -1, bn, an, a->len / an,
1.0, a->b->x, an, b->b->x, bn,
0.0, t->b->x, bn);
//GEMM(ord_b == 1, ord_a == -1, bn, an, a->len / an,
// a->scale*b->scale, a->b->x, an, b->b->x, bn,
// 0.0, t->b->x, bn);
// TODO: decide if transposing A would give better perf.
} else { // Need to transpose B.
printf("Need to transpose B.\n");
}
} else if( (ord_b = ck_ordered(b->n, bnum))) { // Need to transpose A
printf("Need to transpose A.\n");
} else { // Need to transpose both A and B.
printf("Need to transpose A & B.\n");
}
free(anum);
free(bnum);
return t;
}
int StackAllocator::reserve(const int64_t size)
{
int err = OB_SUCCESS;
if (head_->remain() >= size || reserved_->remain() >= size)
{}
else if (OB_SUCCESS != (err = reserve_block(size)))
{
TBSYS_LOG(ERROR, "reserve_block(size=%ld)=>%d", size, err);
}
return err;
}
//****** realloc_fs_blocks*****************
//Allocates at least "blocks_needed" blocks for this file
int8_t realloc_fs_blocks(inode* inode, uint32_t blocks_needed)
{
uint32_t* s_ind = calloc(1, sizeof(block));
if(blocks_needed > inode->blocks)
{
if(inode->blocks <= 8)
{
for(; inode->blocks < MIN(8,blocks_needed); inode->blocks++)
{
inode->data0[inode->blocks] = reserve_block();
}
}
if(inode->blocks < blocks_needed) //still not enough after allocating direct
{
//Determine if a single indirect block has been allocated
if(inode->data1 == 0)
{
inode->data1 = reserve_block();
}
else
{
blk_read(inode->data1,(block*)s_ind);
}
//Allocate the blocks and save in the indirect block
for(;inode->blocks < blocks_needed; inode->blocks++)
{
s_ind[inode->blocks-8] = reserve_block();
}
blk_write(inode->data1,(block*)s_ind);
}
}
free(s_ind);
return 0;
}
// Allocate a new tensor.
// x will be managed by MemSpace.
Tensor *mkTensor(const int nd, const int *shape,
const int nref, MemSpace *mem) {
Tensor *t = tensor_ctor(nd, shape);
t->x = (double *)reserve_block(mem, sizeof(double)*t->len, nref);
return t;
}
//******** mkdir ********************
int8_t cnmkdir(const char* name)
{
char* name_copy = strdup(name);
char name_tok[256];
char entry_name[256];
char* next_name_tok;
dir_entry* entry;
dir_ptr *dir = calloc(1,sizeof(dir_ptr)); //Directory file in memory (e.g. DIR object from filedef.h)
bool last_dir = false;
inode_read(cwd->inode_id, &dir->inode_st); //Start at cwd
dir->inode_id = cwd->inode_id;
next_name_tok = strtok(name_copy, "/");
do
{
//name_tok is the dir we are searching for or going to create
strcpy(name_tok, next_name_tok);
//Read the directory file for this inode
dir->data = calloc(dir->inode_st.blocks,sizeof(block)); //Memory for all directory file blocks
llread(&dir->inode_st, dir->data); //Read the directory file
dir->index = 0;
next_name_tok = strtok(NULL, "/"); //Read the next token
if(next_name_tok == NULL) //This is the last directory in the path
{
last_dir = true;
}
//Find the token in this dir
while((entry = cnreaddir(dir)))
{
memcpy(entry_name, entry->name, entry->name_len);
entry_name[entry->name_len] = 0;
if(strcmp(entry_name, name_tok) == 0) //If this directory already exists
{
if(last_dir)
{
return -1; //Directory already exists
}
else //Read the directory inode
{
dir->inode_id = entry->inode;
inode_read(entry->inode,&dir->inode_st); //Read the next directory's inode
free(dir->data); //Forget the directory we just read
break;
}
}
}
if(last_dir) //Create the directory at the end of the list
{
//Create parent directory entry
entry = (dir_entry*)(((uint8_t*)dir->data)+dir->index);
entry->file_type = ITYPE_DIR;
entry->inode = reserve_inode();
memcpy(entry->name,name_tok,strlen(name_tok));
entry->name_len = strlen(name_tok);
entry->entry_len = entry->name_len + 8;
entry->entry_len += (4 - entry->entry_len % 4); //padding out to 32 bits
dir->inode_st.size += entry->entry_len;
//TODO: handle mkdir block overflow
//Write parent dir and inode
dir->inode_st.modified = time(NULL);
inode_write(dir->inode_id, &dir->inode_st);
blk_write(dir->inode_st.data0[0], dir->data);
//Write new directory inode
inode new_dir_i;
memset(&new_dir_i, 0, sizeof(inode));
uint32_t now = time(NULL);
new_dir_i.modified = now;
new_dir_i.type = ITYPE_DIR;
new_dir_i.size = 0;
new_dir_i.blocks = 1;
new_dir_i.data0[0] = reserve_block();
//Write new directory file
block* new_dir_block = calloc(1,sizeof(block));
// . (self entry)
dir_entry* new_dir_self_entry = (dir_entry*)new_dir_block;
new_dir_self_entry->inode = entry->inode;
new_dir_self_entry->file_type = ITYPE_DIR;
new_dir_self_entry->name_len = 1;
new_dir_self_entry->entry_len = 12;
memcpy(new_dir_self_entry->name, ".", 1);
new_dir_i.size += 12;
// .. (parent entry)
dir_entry* new_dir_parent_entry = (dir_entry*)(((uint8_t*)new_dir_block) + 12);
new_dir_parent_entry->inode = dir->inode_id;
new_dir_parent_entry->file_type = ITYPE_DIR;
new_dir_parent_entry->name_len = 2;
new_dir_parent_entry->entry_len = 12;
memcpy(new_dir_parent_entry->name, "..", 2);
new_dir_i.size += 12;
//Write new dir and inode
inode_write(entry->inode, &new_dir_i);
blk_write(new_dir_i.data0[0], new_dir_block);
free(new_dir_block);
break;
}
} while(1);
free(dir);
free(name_copy);
return 0;
}
