← Back to branch summary

~ubuntu-branches/ubuntu/raring/python-scipy/raring-proposed

« back to all changes in this revision

Viewing changes to Lib/sandbox/pysparse/umfpack/umf_mem_free_tail_block.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-01-07 14:12:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070107141212-mm0ebkh5b37hcpzn
http://bugs.debian.org/402783
* Remove build dependency on python-numpy-dev.
* python-scipy: Depend on python-numpy instead of python-numpy-dev.
* Package builds on other archs than i386. Closes: #402783.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/sandbox/pysparse/umfpack/umf_mem_free_tail_block.c
 
1
/* ========================================================================== */
 
2
/* === UMF_mem_free_tail_block ============================================== */
 
3
/* ========================================================================== */
 
4
 
 
5
/* -------------------------------------------------------------------------- */
 
6
/* UMFPACK Version 4.1 (Apr. 30, 2003), Copyright (c) 2003 by Timothy A.      */
 
7
/* Davis.  All Rights Reserved.  See ../README for License.                   */
 
8
/* email: davis@cise.ufl.edu    CISE Department, Univ. of Florida.            */
 
9
/* web: http://www.cise.ufl.edu/research/sparse/umfpack                       */
 
10
/* -------------------------------------------------------------------------- */
 
11
 
 
12
/* The UMF_mem_* routines manage the Numeric->Memory memory space. */
 
13
 
 
14
/* free a block from the tail of Numeric->memory */
 
15
 
 
16
#include "umf_internal.h"
 
17
 
 
18
GLOBAL void UMF_mem_free_tail_block
 
19
(
 
20
    NumericType *Numeric,
 
21
    Int i
 
22
)
 
23
{
 
24
    Unit *pprev, *pnext, *p, *pbig ;
 
25
    Int sprev ;
 
26
 
 
27
    ASSERT (Numeric != (NumericType *) NULL) ;
 
28
    ASSERT (Numeric->Memory != (Unit *) NULL) ;
 
29
    if (i == EMPTY || i == 0) return ;  /* already deallocated */
 
30
 
 
31
    /* ---------------------------------------------------------------------- */
 
32
    /* get the block */
 
33
    /* ---------------------------------------------------------------------- */
 
34
 
 
35
    p = Numeric->Memory + i ;
 
36
 
 
37
    p-- ;       /* get the corresponding header */
 
38
    DEBUG2 (("free block: p: "ID, (Int) (p-Numeric->Memory))) ;
 
39
    ASSERT (p >= Numeric->Memory + Numeric->itail) ;
 
40
    ASSERT (p < Numeric->Memory + Numeric->size) ;
 
41
    ASSERT (p->header.size > 0) ;               /* block not already free */
 
42
    ASSERT (p->header.prevsize >= 0) ;
 
43
 
 
44
    Numeric->tail_usage -= p->header.size + 1 ;
 
45
 
 
46
    /* ---------------------------------------------------------------------- */
 
47
    /* merge with next free block, if any */
 
48
    /* ---------------------------------------------------------------------- */
 
49
 
 
50
    pnext = p + 1 + p->header.size ;
 
51
    DEBUG2 (("size: "ID" next: "ID" ", p->header.size,
 
52
        (Int) (pnext-Numeric->Memory))) ;
 
53
    ASSERT (pnext < Numeric->Memory + Numeric->size) ;
 
54
    ASSERT (pnext->header.prevsize == p->header.size) ;
 
55
    ASSERT (pnext->header.size != 0) ;
 
56
 
 
57
    if (pnext->header.size < 0)
 
58
    {
 
59
        /* next block is also free - merge with current block */
 
60
        p->header.size += (-(pnext->header.size)) + 1 ;
 
61
        DEBUG2 ((" NEXT FREE ")) ;
 
62
    }
 
63
 
 
64
    /* ---------------------------------------------------------------------- */
 
65
    /* merge with previous free block, if any */
 
66
    /* ---------------------------------------------------------------------- */
 
67
 
 
68
#ifndef NDEBUG
 
69
    if (p == Numeric->Memory + Numeric->itail)
 
70
    {
 
71
        DEBUG2 ((" at top of tail ")) ;
 
72
        ASSERT (p->header.prevsize == 0) ;
 
73
    }
 
74
#endif
 
75
 
 
76
    if (p > Numeric->Memory + Numeric->itail)
 
77
    {
 
78
        ASSERT (p->header.prevsize > 0) ;
 
79
        pprev = p - 1 - p->header.prevsize ;
 
80
        DEBUG2 ((" prev: "ID" ", (Int) (pprev-Numeric->Memory))) ;
 
81
        ASSERT (pprev >= Numeric->Memory + Numeric->itail) ;
 
82
        sprev = pprev->header.size ;
 
83
        if (sprev < 0)
 
84
        {
 
85
            /* previous block is also free - merge it with current block */
 
86
            ASSERT (p->header.prevsize == -sprev) ;
 
87
            pprev->header.size = p->header.size + (-sprev) + 1 ;
 
88
            p = pprev ;
 
89
            DEBUG2 ((" PREV FREE ")) ;
 
90
            /* note that p may now point to Numeric->itail */
 
91
        }
 
92
#ifndef NDEBUG
 
93
        else
 
94
        {
 
95
            ASSERT (p->header.prevsize == sprev) ;
 
96
        }
 
97
#endif
 
98
    }
 
99
 
 
100
    /* ---------------------------------------------------------------------- */
 
101
    /* free the block, p */
 
102
    /* ---------------------------------------------------------------------- */
 
103
 
 
104
    pnext = p + 1 + p->header.size ;
 
105
    ASSERT (pnext < Numeric->Memory + Numeric->size) ;
 
106
 
 
107
    if (p == Numeric->Memory + Numeric->itail)
 
108
    {
 
109
        /* top block in list is freed */
 
110
        Numeric->itail = pnext - Numeric->Memory ;
 
111
        pnext->header.prevsize = 0 ;
 
112
        DEBUG2 ((" NEW TAIL : "ID" ", Numeric->itail)) ;
 
113
        ASSERT (pnext->header.size > 0) ;
 
114
        if (Numeric->ibig != EMPTY && Numeric->ibig <= Numeric->itail)
 
115
        {
 
116
            /* the big free block is now above the tail */
 
117
            Numeric->ibig = EMPTY ;
 
118
        }
 
119
    }
 
120
    else
 
121
    {
 
122
        /* keep track of the biggest free block seen */
 
123
        if (Numeric->ibig == EMPTY)
 
124
        {
 
125
            Numeric->ibig = p - Numeric->Memory ;
 
126
        }
 
127
        else
 
128
        {
 
129
            pbig = Numeric->Memory + Numeric->ibig ;
 
130
            if (-(pbig->header.size) < p->header.size)
 
131
            {
 
132
                Numeric->ibig = p - Numeric->Memory ;
 
133
            }
 
134
        }
 
135
        /* flag the block as free, somewhere in the middle of the tail */
 
136
        pnext->header.prevsize = p->header.size ;
 
137
        p->header.size = -(p->header.size) ;
 
138
    }
 
139
 
 
140
    DEBUG2 (("new p: "ID" freesize: "ID"\n", (Int) (p-Numeric->Memory),
 
141
        -(p->header.size))) ;
 
142
 
 
143
}