src/parsec/disk-image/parsec/parsec-benchmark/pkgs/apps/ferret/src/src/import.c - public/gem5-resources - Git at Google

 /* AUTORIGHTS
 Copyright (C) 2007 Princeton University

 This file is part of Ferret Toolkit.

 Ferret Toolkit is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software Foundation,
 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 #include <cass.h>

 /* file format
  *
  * LINE 1:	<# vecset>	<vecset type:	1 | 2>
  * LINE 2:	<type : int | float>	<dim>
  * LINE 3:	<id 1>	<# vec>
  * LINE 4:	<weight> <vec 1>
  * ...
  * 		<id 2> <# vec>
  * 		<weight> <vec 1>
  * 		...
  */

 #warning to be extended to allow external id

 static void eat_comment (FILE *fin)
 {
 	int c;
 	for (;;)
 	{
 		c = fgetc(fin);
 		if (c != '#') break;
 		for (;;)
 		{
 			c = fgetc(fin);
 			if (c == '\n') break;
 		}
 	}
 	ungetc(c, fin);
 }

 static int _import_vec_int (int32_t *vec, cass_size_t dim, FILE *fin)
 {
 	cass_size_t i;
 	for (i = 0; i < dim; i++)
 	{
 		if (fscanf(fin, "%d", &vec[i]) != 1) return CASS_ERR_IO;
 	}
 	return 0;
 }

 static int _import_vec_float (float *vec, cass_size_t dim, FILE *fin)
 {
 	cass_size_t i;
 	for (i = 0; i < dim; i++)
 	{
 		if (fscanf(fin, "%f", &vec[i]) != 1) return CASS_ERR_IO;
 	}
 	return 0;
 }

 static int _import_vec_bit (chunk_t *vec, cass_size_t dim, FILE *fin)
 {
 	int c;
 	cass_size_t i, j, k;
 	chunk_t chunk = 0;
 	for (;;)
 	{
 		c = fgetc(fin);
 		if (c == EOF) return CASS_ERR_IO;
 		if (c == '0' || c == '1') break;
 	}
 	j = k = 0;
 	ungetc(c, fin);
 	for (i = 0; i < dim; i++)
 	{
 		c = fgetc(fin);
 		if (c != '0' && c != '1') return CASS_ERR_IO;
 		chunk = chunk << 1;
 		chunk |= c - '0';
 		j++;
 		if (j == CHUNK_BIT)
 		{
 			vec[k++] = chunk;
 			j = 0;
 		}
 	}
 	return 0;
 }


 static int _export_vec_int (int32_t *vec, cass_size_t dim, FILE *fout)
 {
 	cass_size_t i;
 	for (i = 0; i < dim; i++)
 	{
 		if (i > 0) fprintf(fout, "\t");
 		if (fprintf(fout, "%d", vec[i]) <= 0) return CASS_ERR_IO;
 	}
 	fprintf(fout, "\n");
 	return 0;
 }

 static int _export_vec_float (float *vec, cass_size_t dim, FILE *fout)
 {
 	cass_size_t i;
 	for (i = 0; i < dim; i++)
 	{
 		if (i > 0) fprintf(fout, "\t");
 		if (fprintf(fout, "%f", vec[i]) <= 0) return CASS_ERR_IO;
 	}
 	fprintf(fout, "\n");
 	return 0;
 }

 static int _export_vec_bit (chunk_t *vec, cass_size_t dim, FILE *fout)
 {
 	int c, i, j, k;
 	chunk_t chunk;
 	j = k = 0;
 	chunk = vec[k];
 	for (i = 0; i < dim; i++)
 	{
 		c = chunk & 1;
 		chunk = chunk >> 1;
 		fprintf(fout, "%c", '0'+c);
 		j++;
 		if (j == CHUNK_BIT)
 		{
 			k++;
 			chunk = vec[k];
 			j = 0;
 		}
 	}
 	fprintf(fout, "\n");
 	return 0;
 }

 int cass_table_import_data(cass_table_t *table, char *fname)
 {
 	int ret;
 	FILE *fin;
 	cass_size_t dim;
 	char objname[BUFSIZ];
 	uint32_t j, k, l;
 	cass_dataset_t *ds;
 	cass_vec_t *vec;

 	cass_vecset_id_t vecset_start;

 	assert(table->opr->type & CASS_DATA);

 	ds = &((struct raw_private *)table->__private)->dataset;

 	vecset_start = ds->num_vecset;

 	assert(table->loaded);

 	fin = fopen(fname, "r");
 	if (fin == NULL) return CASS_ERR_IO;

 	ret = CASS_ERR_IO;

 	dim = table->cfg->vec_dim;

 	for (;;)
 	{
 	    eat_comment(fin);

 	    if (fscanf(fin, "%s%u", objname, &l) != 2) break;

 	    ret = cass_map_dataobj_to_id(table->map, objname, &k);
 	    if (ret < 0) {
 		// new obj.
 		ret = cass_map_insert(table->map, &k, objname);
 		if (ret < 0)
 		    goto err;
 	    }
 	    if (ds->num_vecset < k)
 		ds->num_vecset = k;

 	    if (ds->num_vecset + 1 > ds->max_vecset)
 	    {
 		ds->max_vecset = grow(ds->max_vecset, ds->num_vecset + 1);
 		ds->vecset = (cass_vecset_t *)realloc(ds->vecset, sizeof (cass_vecset_t) * ds->max_vecset);
 		ret = CASS_ERR_OUTOFMEM;
 		if (ds->vecset == NULL) return ret;
 	    }

 	    ret = CASS_ERR_IO;

 	    ds->vecset[k].num_regions = l;
 	    if (table->cfg->vecset_type == CASS_VECSET_SINGLE && l != 1) goto err;
 	    ds->vecset[k].start_vecid = ds->num_vec;

 	    if (ds->num_vec + l > ds->max_vec)
 	    {
 		ds->max_vec = grow(ds->max_vec, ds->num_vec + l);
 		ds->vec = (cass_vec_t *)realloc(ds->vec,  ds->vec_size * ds->max_vec);
 		ret = CASS_ERR_OUTOFMEM;
 		if (ds->vec == NULL) return ret;
 		ret = CASS_ERR_IO;
 	    }

 	    vec = (cass_vec_t *)((void *)ds->vec + (ds->num_vec * ds->vec_size));
 	    for (j = 0; j < l; j++)
 	    {
 		ret = CASS_ERR_IO;
 		vec->parent = ds->num_vecset;
 		eat_comment(fin);
 		if (fscanf(fin, "%f", &vec->weight) != 1) goto err;
 		switch (table->cfg->vec_type)
 		{
 			case CASS_VEC_INT: ret = _import_vec_int(vec->u.int_data, dim, fin); break;
 			case CASS_VEC_FLOAT: ret = _import_vec_float(vec->u.float_data, dim, fin); break;
 			case CASS_VEC_BIT: ret = _import_vec_bit(vec->u.bit_data, dim, fin); break;
 			default: assert(0);
 		}
 		if (ret != 0) goto err;
 		vec = (cass_vec_t *)((void *)vec + ds->vec_size);
 		ds->num_vec++;
 	    }
 	    ds->num_vecset++;
 	}

 	table->dirty = 1;

 	fclose(fin);
 	fin = NULL;

 	/* cascade insert */
     	ARRAY_BEGIN_FOREACH(table->children, cass_table_t *p)
     	{
        		ret = cass_table_batch_insert(p, ds, vecset_start, ds->num_vecset -1);
 		if (ret != 0) goto err;
     	} ARRAY_END_FOREACH;


 	return 0;

 err:
 	if (fin != NULL) fclose(fin);
 	return ret;
 }

 int cass_table_import_direct_data(cass_table_t *table, char *fname)
 {
 	int ret;
 	FILE *fin;
 	cass_size_t dim;
 	uint32_t j, k, l;
 	cass_dataset_t *ds;
 	cass_vec_t *vec;

 	cass_vecset_id_t vecset_start;

 	assert(table->opr->type & CASS_DATA);

 	ds = &((struct raw_private *)table->__private)->dataset;

 	vecset_start = ds->num_vecset;

 	assert(table->loaded);

 	fin = fopen(fname, "r");
 	if (fin == NULL) return CASS_ERR_IO;

 	ret = CASS_ERR_IO;

 	dim = table->cfg->vec_dim;

 	for (;;)
 	{


 	    if (ds->num_vecset + 1 > ds->max_vecset)
 	    {
 		ds->max_vecset = grow(ds->max_vecset, ds->num_vecset + 1);
 		ds->vecset = (cass_vecset_t *)realloc(ds->vecset, sizeof (cass_vecset_t) * ds->max_vecset);
 		ret = CASS_ERR_OUTOFMEM;
 		if (ds->vecset == NULL) return ret;
 	    }

 	    ret = CASS_ERR_IO;

 	    eat_comment(fin);

 	    if (fscanf(fin, "%u%u", &k, &l) != 2) break;
 	    if (k != ds->num_vecset) goto err;
 	    ds->vecset[k].num_regions = l;
 	    if (table->cfg->vecset_type == CASS_VECSET_SINGLE && l != 1) goto err;
 	    ds->vecset[k].start_vecid = ds->num_vec;

 	    if (ds->num_vec + l > ds->max_vec)
 	    {
 		ds->max_vec = grow(ds->max_vec, ds->num_vec + l);
 		ds->vec = (cass_vec_t *)realloc(ds->vec,  ds->vec_size * ds->max_vec);
 		ret = CASS_ERR_OUTOFMEM;
 		if (ds->vec == NULL) return ret;
 		ret = CASS_ERR_IO;
 	    }

 	    vec = (cass_vec_t *)((void *)ds->vec + (ds->num_vec * ds->vec_size));
 	    for (j = 0; j < l; j++)
 	    {
 		ret = CASS_ERR_IO;
 		vec->parent = ds->num_vecset;
 		eat_comment(fin);
 		if (fscanf(fin, "%f", &vec->weight) != 1) goto err;
 		switch (table->cfg->vec_type)
 		{
 			case CASS_VEC_INT: ret = _import_vec_int(vec->u.int_data, dim, fin); break;
 			case CASS_VEC_FLOAT: ret = _import_vec_float(vec->u.float_data, dim, fin); break;
 			case CASS_VEC_BIT: ret = _import_vec_bit(vec->u.bit_data, dim, fin); break;
 			default: assert(0);
 		}
 		if (ret != 0) goto err;
 		vec = (cass_vec_t *)((void *)vec + ds->vec_size);
 		ds->num_vec++;
 	    }
 	    ds->num_vecset++;
 	}

 	table->dirty = 1;

 	fclose(fin);
 	fin = NULL;

 	/* cascade insert */
     	ARRAY_BEGIN_FOREACH(table->children, cass_table_t *p)
     	{
        		ret = cass_table_batch_insert(p, ds, vecset_start, ds->num_vecset -1);
 		if (ret != 0) goto err;
     	} ARRAY_END_FOREACH;


 	return 0;

 err:
 	if (fin != NULL) fclose(fin);
 	return ret;
 }

 int cass_table_export_data(cass_table_t *table, char *fname)
 {
 	FILE *fout;
 	cass_dataset_t *ds;
 	cass_vec_t *vec;
 	uint32_t i, j, k, dim;
 	char *p;

 	assert(table->opr->type & CASS_DATA ||
 		table->opr->type & CASS_VEC_SKETCH);

 	ds = &((struct raw_private *)table->__private)->dataset;

 	assert(ds->loaded);

 	fout = fopen(fname, "w");
 	if (fout == NULL) return CASS_ERR_IO;

 	dim = table->cfg->vec_dim;

 	if (table->cfg->vecset_type == CASS_VECSET_NONE) k = 0;
 	else if (table->cfg->vecset_type == CASS_VECSET_SINGLE) k = 1;
 	else if (table->cfg->vecset_type == CASS_VECSET_SET) k = 2;
 	else assert(0);

 	fprintf(fout, "# %u\t%u\n", ds->num_vecset, k);


 	if (table->cfg->vec_type == CASS_VEC_INT)
 	{
 		p = "int";
 	}
 	else if (table->cfg->vec_type == CASS_VEC_FLOAT)
 	{
 		p = "float";
 	}
 	else if (table->cfg->vec_type == CASS_VEC_BIT)
 	{
 		p = "bit";
 	}

 	fprintf(fout, "# %s\t%u\n", p, dim);

 	if ((ds->flags & CASS_DATASET_BOTH) == CASS_DATASET_BOTH)
 	{
 		vec = ds->vec;
 		for (i = 0; i < ds->num_vecset; i++)
 		{
 			char *name;
 			cass_map_id_to_dataobj(table->map, i, &name);
 			fprintf(fout, "%s\t%u\n", name, ds->vecset[i].num_regions);
 			k = ds->vecset[i].start_vecid;
 			assert((void *)ds->vec + k * ds->vec_size == vec);
 			for (j = 0; j < ds->vecset[i].num_regions; j++)
 			{
 				fprintf(fout, "%f\t", vec->weight);
 				switch (table->cfg->vec_type)
 				{
 					case CASS_VEC_INT: _export_vec_int(vec->u.int_data, dim, fout); break;
 					case CASS_VEC_FLOAT: _export_vec_float(vec->u.float_data, dim, fout); break;
 					case CASS_VEC_BIT: _export_vec_bit(vec->u.bit_data, dim, fout); break;
 					default: assert(0);
 				}
 				vec = (cass_vec_t *)((void *)vec + ds->vec_size);
 			}
 		}
 	}
 	else if (ds->flags & CASS_DATASET_VEC)
 	{
 		vec = ds->vec;
 		fprintf(fout, "#weight\tparent\tvector\n");
 		for (i = 0; i < ds->num_vec; i++)
 		{
 			fprintf(fout, "%f\t", vec->weight);
 			fprintf(fout, "%u\t", vec->parent);
 			switch (table->cfg->vec_type)
 			{
 				case CASS_VEC_INT: _export_vec_int(vec->u.int_data, dim, fout); break;
 				case CASS_VEC_FLOAT: _export_vec_float(vec->u.float_data, dim, fout); break;
 				case CASS_VEC_BIT: _export_vec_bit(vec->u.bit_data, dim, fout); break;
 				default: assert(0);
 			}
 			vec = (cass_vec_t *)((void *)vec + ds->vec_size);
 		}
 	}

 	fclose(fout);
 	return 0;


 }
	/* AUTORIGHTS
	Copyright (C) 2007 Princeton University

	This file is part of Ferret Toolkit.

	Ferret Toolkit is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2, or (at your option)
	any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software Foundation,
	Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/
	#include <cass.h>

	/* file format
	*
	* LINE 1: <# vecset> <vecset type: 1 \| 2>
	* LINE 2: <type : int \| float> <dim>
	* LINE 3: <id 1> <# vec>
	* LINE 4: <weight> <vec 1>
	* ...
	* <id 2> <# vec>
	* <weight> <vec 1>
	* ...
	*/

	#warning to be extended to allow external id

	static void eat_comment (FILE *fin)
	{
	int c;
	for (;;)
	{
	c = fgetc(fin);
	if (c != '#') break;
	for (;;)
	{
	c = fgetc(fin);
	if (c == '\n') break;
	}
	}
	ungetc(c, fin);
	}

	static int _import_vec_int (int32_t vec, cass_size_t dim, FILE fin)
	{
	cass_size_t i;
	for (i = 0; i < dim; i++)
	{
	if (fscanf(fin, "%d", &vec[i]) != 1) return CASS_ERR_IO;
	}
	return 0;
	}

	static int _import_vec_float (float vec, cass_size_t dim, FILE fin)
	{
	cass_size_t i;
	for (i = 0; i < dim; i++)
	{
	if (fscanf(fin, "%f", &vec[i]) != 1) return CASS_ERR_IO;
	}
	return 0;
	}

	static int _import_vec_bit (chunk_t vec, cass_size_t dim, FILE fin)
	{
	int c;
	cass_size_t i, j, k;
	chunk_t chunk = 0;
	for (;;)
	{
	c = fgetc(fin);
	if (c == EOF) return CASS_ERR_IO;
	if (c == '0' \|\| c == '1') break;
	}
	j = k = 0;
	ungetc(c, fin);
	for (i = 0; i < dim; i++)
	{
	c = fgetc(fin);
	if (c != '0' && c != '1') return CASS_ERR_IO;
	chunk = chunk << 1;
	chunk \|= c - '0';
	j++;
	if (j == CHUNK_BIT)
	{
	vec[k++] = chunk;
	j = 0;
	}
	}
	return 0;
	}


	static int _export_vec_int (int32_t vec, cass_size_t dim, FILE fout)
	{
	cass_size_t i;
	for (i = 0; i < dim; i++)
	{
	if (i > 0) fprintf(fout, "\t");
	if (fprintf(fout, "%d", vec[i]) <= 0) return CASS_ERR_IO;
	}
	fprintf(fout, "\n");
	return 0;
	}

	static int _export_vec_float (float vec, cass_size_t dim, FILE fout)
	{
	cass_size_t i;
	for (i = 0; i < dim; i++)
	{
	if (i > 0) fprintf(fout, "\t");
	if (fprintf(fout, "%f", vec[i]) <= 0) return CASS_ERR_IO;
	}
	fprintf(fout, "\n");
	return 0;
	}

	static int _export_vec_bit (chunk_t vec, cass_size_t dim, FILE fout)
	{
	int c, i, j, k;
	chunk_t chunk;
	j = k = 0;
	chunk = vec[k];
	for (i = 0; i < dim; i++)
	{
	c = chunk & 1;
	chunk = chunk >> 1;
	fprintf(fout, "%c", '0'+c);
	j++;
	if (j == CHUNK_BIT)
	{
	k++;
	chunk = vec[k];
	j = 0;
	}
	}
	fprintf(fout, "\n");
	return 0;
	}

	int cass_table_import_data(cass_table_t table, char fname)
	{
	int ret;
	FILE *fin;
	cass_size_t dim;
	char objname[BUFSIZ];
	uint32_t j, k, l;
	cass_dataset_t *ds;
	cass_vec_t *vec;

	cass_vecset_id_t vecset_start;

	assert(table->opr->type & CASS_DATA);

	ds = &((struct raw_private *)table->__private)->dataset;

	vecset_start = ds->num_vecset;

	assert(table->loaded);

	fin = fopen(fname, "r");
	if (fin == NULL) return CASS_ERR_IO;

	ret = CASS_ERR_IO;

	dim = table->cfg->vec_dim;

	for (;;)
	{
	eat_comment(fin);

	if (fscanf(fin, "%s%u", objname, &l) != 2) break;

	ret = cass_map_dataobj_to_id(table->map, objname, &k);
	if (ret < 0) {
	// new obj.
	ret = cass_map_insert(table->map, &k, objname);
	if (ret < 0)
	goto err;
	}
	if (ds->num_vecset < k)
	ds->num_vecset = k;

	if (ds->num_vecset + 1 > ds->max_vecset)
	{
	ds->max_vecset = grow(ds->max_vecset, ds->num_vecset + 1);
	ds->vecset = (cass_vecset_t )realloc(ds->vecset, sizeof (cass_vecset_t) ds->max_vecset);
	ret = CASS_ERR_OUTOFMEM;
	if (ds->vecset == NULL) return ret;
	}

	ret = CASS_ERR_IO;

	ds->vecset[k].num_regions = l;
	if (table->cfg->vecset_type == CASS_VECSET_SINGLE && l != 1) goto err;
	ds->vecset[k].start_vecid = ds->num_vec;

	if (ds->num_vec + l > ds->max_vec)
	{
	ds->max_vec = grow(ds->max_vec, ds->num_vec + l);
	ds->vec = (cass_vec_t )realloc(ds->vec, ds->vec_size ds->max_vec);
	ret = CASS_ERR_OUTOFMEM;
	if (ds->vec == NULL) return ret;
	ret = CASS_ERR_IO;
	}

	vec = (cass_vec_t )((void )ds->vec + (ds->num_vec * ds->vec_size));
	for (j = 0; j < l; j++)
	{
	ret = CASS_ERR_IO;
	vec->parent = ds->num_vecset;
	eat_comment(fin);
	if (fscanf(fin, "%f", &vec->weight) != 1) goto err;
	switch (table->cfg->vec_type)
	{
	case CASS_VEC_INT: ret = _import_vec_int(vec->u.int_data, dim, fin); break;
	case CASS_VEC_FLOAT: ret = _import_vec_float(vec->u.float_data, dim, fin); break;
	case CASS_VEC_BIT: ret = _import_vec_bit(vec->u.bit_data, dim, fin); break;
	default: assert(0);
	}
	if (ret != 0) goto err;
	vec = (cass_vec_t )((void )vec + ds->vec_size);
	ds->num_vec++;
	}
	ds->num_vecset++;
	}

	table->dirty = 1;

	fclose(fin);
	fin = NULL;

	/* cascade insert */
	ARRAY_BEGIN_FOREACH(table->children, cass_table_t *p)
	{
	ret = cass_table_batch_insert(p, ds, vecset_start, ds->num_vecset -1);
	if (ret != 0) goto err;
	} ARRAY_END_FOREACH;


	return 0;

	err:
	if (fin != NULL) fclose(fin);
	return ret;
	}

	int cass_table_import_direct_data(cass_table_t table, char fname)
	{
	int ret;
	FILE *fin;
	cass_size_t dim;
	uint32_t j, k, l;
	cass_dataset_t *ds;
	cass_vec_t *vec;

	cass_vecset_id_t vecset_start;

	assert(table->opr->type & CASS_DATA);

	ds = &((struct raw_private *)table->__private)->dataset;

	vecset_start = ds->num_vecset;

	assert(table->loaded);

	fin = fopen(fname, "r");
	if (fin == NULL) return CASS_ERR_IO;

	ret = CASS_ERR_IO;

	dim = table->cfg->vec_dim;

	for (;;)
	{


	if (ds->num_vecset + 1 > ds->max_vecset)
	{
	ds->max_vecset = grow(ds->max_vecset, ds->num_vecset + 1);
	ds->vecset = (cass_vecset_t )realloc(ds->vecset, sizeof (cass_vecset_t) ds->max_vecset);
	ret = CASS_ERR_OUTOFMEM;
	if (ds->vecset == NULL) return ret;
	}

	ret = CASS_ERR_IO;

	eat_comment(fin);

	if (fscanf(fin, "%u%u", &k, &l) != 2) break;
	if (k != ds->num_vecset) goto err;
	ds->vecset[k].num_regions = l;
	if (table->cfg->vecset_type == CASS_VECSET_SINGLE && l != 1) goto err;
	ds->vecset[k].start_vecid = ds->num_vec;

	if (ds->num_vec + l > ds->max_vec)
	{
	ds->max_vec = grow(ds->max_vec, ds->num_vec + l);
	ds->vec = (cass_vec_t )realloc(ds->vec, ds->vec_size ds->max_vec);
	ret = CASS_ERR_OUTOFMEM;
	if (ds->vec == NULL) return ret;
	ret = CASS_ERR_IO;
	}

	vec = (cass_vec_t )((void )ds->vec + (ds->num_vec * ds->vec_size));
	for (j = 0; j < l; j++)
	{
	ret = CASS_ERR_IO;
	vec->parent = ds->num_vecset;
	eat_comment(fin);
	if (fscanf(fin, "%f", &vec->weight) != 1) goto err;
	switch (table->cfg->vec_type)
	{
	case CASS_VEC_INT: ret = _import_vec_int(vec->u.int_data, dim, fin); break;
	case CASS_VEC_FLOAT: ret = _import_vec_float(vec->u.float_data, dim, fin); break;
	case CASS_VEC_BIT: ret = _import_vec_bit(vec->u.bit_data, dim, fin); break;
	default: assert(0);
	}
	if (ret != 0) goto err;
	vec = (cass_vec_t )((void )vec + ds->vec_size);
	ds->num_vec++;
	}
	ds->num_vecset++;
	}

	table->dirty = 1;

	fclose(fin);
	fin = NULL;

	/* cascade insert */
	ARRAY_BEGIN_FOREACH(table->children, cass_table_t *p)
	{
	ret = cass_table_batch_insert(p, ds, vecset_start, ds->num_vecset -1);
	if (ret != 0) goto err;
	} ARRAY_END_FOREACH;


	return 0;

	err:
	if (fin != NULL) fclose(fin);
	return ret;
	}

	int cass_table_export_data(cass_table_t table, char fname)
	{
	FILE *fout;
	cass_dataset_t *ds;
	cass_vec_t *vec;
	uint32_t i, j, k, dim;
	char *p;

	assert(table->opr->type & CASS_DATA \|\|
	table->opr->type & CASS_VEC_SKETCH);

	ds = &((struct raw_private *)table->__private)->dataset;

	assert(ds->loaded);

	fout = fopen(fname, "w");
	if (fout == NULL) return CASS_ERR_IO;

	dim = table->cfg->vec_dim;

	if (table->cfg->vecset_type == CASS_VECSET_NONE) k = 0;
	else if (table->cfg->vecset_type == CASS_VECSET_SINGLE) k = 1;
	else if (table->cfg->vecset_type == CASS_VECSET_SET) k = 2;
	else assert(0);

	fprintf(fout, "# %u\t%u\n", ds->num_vecset, k);


	if (table->cfg->vec_type == CASS_VEC_INT)
	{
	p = "int";
	}
	else if (table->cfg->vec_type == CASS_VEC_FLOAT)
	{
	p = "float";
	}
	else if (table->cfg->vec_type == CASS_VEC_BIT)
	{
	p = "bit";
	}

	fprintf(fout, "# %s\t%u\n", p, dim);

	if ((ds->flags & CASS_DATASET_BOTH) == CASS_DATASET_BOTH)
	{
	vec = ds->vec;
	for (i = 0; i < ds->num_vecset; i++)
	{
	char *name;
	cass_map_id_to_dataobj(table->map, i, &name);
	fprintf(fout, "%s\t%u\n", name, ds->vecset[i].num_regions);
	k = ds->vecset[i].start_vecid;
	assert((void )ds->vec + k ds->vec_size == vec);
	for (j = 0; j < ds->vecset[i].num_regions; j++)
	{
	fprintf(fout, "%f\t", vec->weight);
	switch (table->cfg->vec_type)
	{
	case CASS_VEC_INT: _export_vec_int(vec->u.int_data, dim, fout); break;
	case CASS_VEC_FLOAT: _export_vec_float(vec->u.float_data, dim, fout); break;
	case CASS_VEC_BIT: _export_vec_bit(vec->u.bit_data, dim, fout); break;
	default: assert(0);
	}
	vec = (cass_vec_t )((void )vec + ds->vec_size);
	}
	}
	}
	else if (ds->flags & CASS_DATASET_VEC)
	{
	vec = ds->vec;
	fprintf(fout, "#weight\tparent\tvector\n");
	for (i = 0; i < ds->num_vec; i++)
	{
	fprintf(fout, "%f\t", vec->weight);
	fprintf(fout, "%u\t", vec->parent);
	switch (table->cfg->vec_type)
	{
	case CASS_VEC_INT: _export_vec_int(vec->u.int_data, dim, fout); break;
	case CASS_VEC_FLOAT: _export_vec_float(vec->u.float_data, dim, fout); break;
	case CASS_VEC_BIT: _export_vec_bit(vec->u.bit_data, dim, fout); break;
	default: assert(0);
	}
	vec = (cass_vec_t )((void )vec + ds->vec_size);
	}
	}

	fclose(fout);
	return 0;


	}