blob: 0a6ffe513128c762a8a86608cd0e5273caf88247 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
/* fcs_isa.c - Freecell Solver Indirect State Allocation Routines
Written by Shlomi Fish, 2000
This file is distributed under the public domain.
*/
#include <stdlib.h>
#include <stdio.h>
#include "fcs_config.h"
#include "state.h"
#include "fcs.h"
#include "fcs_isa.h"
#ifdef DMALLOC
#include "dmalloc.h"
#endif
void freecell_solver_state_ia_init(freecell_solver_hard_thread_t * hard_thread)
{
hard_thread->max_num_state_packs = IA_STATE_PACKS_GROW_BY;
hard_thread->state_packs = (fcs_state_with_locations_t * *)malloc(sizeof(fcs_state_with_locations_t *) * hard_thread->max_num_state_packs);
hard_thread->num_state_packs = 1;
/*
* All the states should fit in one 64KB segment. Now, we allocate as
* many states as possible, minus one, so we would be certain that there
* would be place for the overhead required by the malloc algorithm.
* */
hard_thread->state_pack_len = (0x010000 / sizeof(fcs_state_with_locations_t)) - 1;
hard_thread->state_packs[0] = malloc(hard_thread->state_pack_len*sizeof(fcs_state_with_locations_t));
hard_thread->num_states_in_last_pack = 0;
}
#if 0
fcs_state_with_locations_t * fcs_state_ia_alloc(freecell_solver_hard_thread_t * hard_thread)
{
if (hard_thread->num_states_in_last_pack == hard_thread->state_pack_len)
{
if (hard_thread->num_state_packs == hard_thread->max_num_state_packs)
{
hard_thread->max_num_state_packs += IA_STATE_PACKS_GROW_BY;
hard_thread->state_packs = (fcs_state_with_locations_t * *)realloc(hard_thread->state_packs, sizeof(fcs_state_with_locations_t *) * hard_thread->max_num_state_packs);
}
hard_thread->state_packs[hard_thread->num_state_packs] = malloc(hard_thread->state_pack_len * sizeof(fcs_state_with_locations_t));
hard_thread->num_state_packs++;
hard_thread->num_states_in_last_pack = 0;
}
return &(hard_thread->state_packs[hard_thread->num_state_packs-1][hard_thread->num_states_in_last_pack++]);
}
#endif
#if 0
void fcs_state_ia_release(freecell_solver_hard_thread_t * hard_thread)
{
hard_thread->num_states_in_last_pack--;
}
#endif
void freecell_solver_state_ia_finish(freecell_solver_hard_thread_t * hard_thread)
{
int a;
for(a=0;a<hard_thread->num_state_packs;a++)
{
free(hard_thread->state_packs[a]);
}
free(hard_thread->state_packs);
hard_thread->state_packs = NULL;
}
void freecell_solver_state_ia_foreach(freecell_solver_hard_thread_t * hard_thread, void (*ptr_function)(fcs_state_with_locations_t *, void *), void * context)
{
int p,s;
for(p=0;p<hard_thread->num_state_packs-1;p++)
{
for(s=0 ; s < hard_thread->state_pack_len ; s++)
{
ptr_function(&(hard_thread->state_packs[p][s]), context);
}
}
for(s=0; s < hard_thread->num_states_in_last_pack ; s++)
{
ptr_function(&(hard_thread->state_packs[p][s]), context);
}
}
|
