/* Create a new vector which is a *view* into an already existing vector.
The new and parent vectors share the same data, and modifying the data in
either will modify both vectors. One the other hand, we do not have to copy
any data to create a view.
*/
struct vector* vector_new_view(struct linalg_obj* parent, double* view, int length) {
assert(length >= 0);
// TODO: Make this view check work.
/* Check that pointers to the beginning and end of view vector live
within the data segment of the parent object.
This doesn't work because matricies have no length. This could be
a property of linalg_obj, but then a macro would be needed to
make the lookup type generic.
assert(DATA(parent) <= view && view < DATA(parent) + parent->length);
assert(view + length <= DATA(parent) + parent->length);
*/
struct vector* new_vector = malloc(sizeof(struct vector));
check_memory((void*)new_vector);
DATA(new_vector) = view;
new_vector->length = length;
OWNS_MEMORY(new_vector) = false;
MEMORY_OWNER(new_vector) = parent;
REF_COUNT(new_vector) = 0;
REF_COUNT(parent) += 1;
return new_vector;
}
/*-------------------------------------------------------------------------
* Function: lite_SC_mark
*
* Purpose: Change the reference count by N
*
* Return: Success: New reference count.
*
* Failure: -1
*
* Programmer: Adapted from PACT SCORE
* Mar 12, 1996
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
lite_SC_mark (lite_SC_byte *p, int n) {
mem_header *space;
mem_descriptor *desc;
if (p == NULL) return(-1);
space = ((mem_header *) p) - 1;
desc = &space->block;
if (!SCORE_BLOCK_P(desc)) return(-1);
if (REF_COUNT(desc) < UNCOLLECT) REF_COUNT(desc) += n;
return(REF_COUNT(desc));
}
void vector_free(struct vector* v) {
struct linalg_obj* mem_owner;
if(OWNS_MEMORY(v)) {
if(REF_COUNT(v) == 0) {
free(DATA(v));
free(v);
} else {
raise_non_zero_reference_free_error();
}
} else {
if(REF_COUNT(v) == 0) {
mem_owner = MEMORY_OWNER(v);
REF_COUNT(mem_owner) -= 1;
free(v);
} else {
raise_non_zero_reference_free_error();
}
}
}
/*-------------------------------------------------------------------------
* Function: lite_SC_free
*
* Purpose: The complementary routine for lite_SC_alloc(). Free all
* the space including the counter.
*
* Return: Success: TRUE
*
* Failure: FALSE
*
* Programmer: Adapted from PACT SCORE
* Mar 12, 1996
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
lite_SC_free (lite_SC_byte *p) {
mem_header *space;
mem_descriptor *desc;
unsigned long nbp;
if (p == NULL) return(TRUE);
space = ((mem_header *) p) - 1;
desc = &space->block;
if (!SCORE_BLOCK_P(desc)) return(FALSE);
if (REF_COUNT(desc) == UNCOLLECT) return(TRUE);
if (--REF_COUNT(desc) > 0) return(TRUE);
nbp = BLOCK_LENGTH(desc) + Sz;
UNASSIGN_BLOCK(desc);
lite_SC_c_sp_free += (nbp - Sz);
SC_MEM_COUNT;
if (_SC_zero_space) {
memset(space, 0, nbp);
} else {
#ifdef NEED_MEM_TRACE
desc->name = NULL;
desc->id = 0L;
desc->type = 0;
#endif
desc->ref_count = 0;
desc->length = 0L;
}
_SC_prim_free((lite_SC_byte *) space, nbp);
_SC_n_mem_blocks--;
return(TRUE);
}
/*-------------------------------------------------------------------------
* Function: lite_SC_ref_count
*
* Purpose: Reference count.
*
* Return: Success: Return the reference count of the given
* object.
*
* Failure: -1
*
* Programmer: Adapted from PACT SCORE
* Mar 12, 1996
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
lite_SC_ref_count (lite_SC_byte *p) {
mem_header *space;
mem_descriptor *desc;
if (p == NULL) return(-1);
space = ((mem_header *) p) - 1;
desc = &space->block;
if (!SCORE_BLOCK_P(desc)) return(-1);
return((int) REF_COUNT(desc));
}
struct vector* vector_new(int length) {
assert(length >= 0);
struct vector* new_vector = malloc(sizeof(struct vector));
check_memory((void*) new_vector);
DATA(new_vector) = malloc((sizeof(double)) * length);
check_memory((void*) DATA(new_vector));
new_vector->length = length;
OWNS_MEMORY(new_vector)= true;
MEMORY_OWNER(new_vector) = NULL;
REF_COUNT(new_vector) = 0;
return new_vector;
}
