int skip_list_insert(key_t key, value_t value, skip_list_t* sl)
{
skip_node_t *prev, *cur;
prev = sl->header;
cur = NULL;
/* store the node at where cur drop to lower level */
skip_node_t* prev_nodes_path[MAX_SKIP_LIST_LEVEL];
memset(prev_nodes_path, 0, MAX_SKIP_LIST_LEVEL);
/* first, find the insert position */
int l = sl->level - 1;
for ( ; l >= 0; --l) {
while ( (cur = prev->forwards[l]) && cur->key < key )
prev = cur;
prev_nodes_path[l] = prev;
}
/* return if cur's key is the same as key, say, already exists,
* with value updated.*/
if ( cur && cur->key == key ) {
cur->value = value;
return 1;
}
/* create a new node with newly-generated level */
int node_level = gen_level();
skip_node_t *node = skip_node_create(key, value, node_level);
if ( ! node ) {
return 0;
}
/* update skip list's level and the corresponding forwards pointers
* if the newly-generated level for current node is greater than
* that of skip list.
* */
if ( node_level > sl->level ) {
l = sl->level;
for ( ; l < node_level; ++l ) {
prev_nodes_path[l] = sl->header;
}
/* update after upper actions */
sl->level = node_level;
}
/* insert newly-created node into skip list with both the node' members
* properly initialized and the skip list is properly updated by prev_nodes_path.
* */
l = node_level - 1;
for ( ; l >= 0; --l ) {
node->forwards[l] = prev_nodes_path[l]->forwards[l];
prev_nodes_path[l]->forwards[l] = node;
}
return 1;
}
static bool
test_box(int level)
{
int size = TEX_SIZE >> level;
int z,x,y,i;
bool pass = true;
float *e, *observed;
observed = malloc(size * size * size * 4 * sizeof(float));
glGetTexImage(GL_TEXTURE_3D, level, GL_RGBA, GL_FLOAT, observed);
e = malloc(size * size * size * 4 * sizeof(float));
gen_level(level, e);
for (z = 0; z < size; z++) {
for (y = 0; y < size; y++) {
for (x = 0; x < size; x++) {
float *probe = &observed[(y*size+x)*4];
float *expected = &e[(y*size+x)*4];
for (i = 0; i < 4; ++i) {
if (fabs(probe[i] - expected[i]) >= piglit_tolerance[i]) {
printf("Probe color at (%i,%i,%i)\n", x, y, z);
printf(" Expected: %f %f %f %f\n",
expected[0], expected[1], expected[2], expected[3]);
printf(" Observed: %f %f %f %f\n",
probe[0], probe[1], probe[2], probe[3]);
printf(" when testing level %i\n", level);
pass = false;
goto done;
}
}
}
}
}
done:
free(e);
free(observed);
return pass;
}
static GLuint
create_tex3d(void)
{
GLuint tex;
float *p;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_3D, tex);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexStorage3D(GL_TEXTURE_3D, TEX_LEVELS, format,
TEX_SIZE, TEX_SIZE, TEX_SIZE);
p = malloc(TEX_SIZE * TEX_SIZE * TEX_SIZE * 4 * sizeof(float));
gen_level(0, p);
glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, TEX_SIZE, TEX_SIZE, TEX_SIZE,
GL_RGBA, GL_FLOAT, p);
free(p);
glGenerateMipmap(GL_TEXTURE_3D);
return tex;
}
