Mercurial > urweb

comparison src/c/urweb.c @ 2286:0bdfec16a01d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fix issue with one-element caches. Locking still WIP.
author Ziv Scully <ziv@mit.edu>
date Fri, 13 Nov 2015 01:04:32 -0500
parents ad3ce1528f71
children 08203f93dbc3
comparison
equal deleted inserted replaced
2285:ad3ce1528f71 2286:0bdfec16a01d
4639 size_t numKeys = cache->numKeys; 4639 size_t numKeys = cache->numKeys;
4640 char *key = uw_Sqlcache_allocKeyBuffer(keys, numKeys); 4640 char *key = uw_Sqlcache_allocKeyBuffer(keys, numKeys);
4641 char *buf = key; 4641 char *buf = key;
4642 time_t timeInvalid = cache->timeInvalid; 4642 time_t timeInvalid = cache->timeInvalid;
4643 uw_Sqlcache_Entry *entry; 4643 uw_Sqlcache_Entry *entry;
4644 while (numKeys-- > 0) { 4644 if (numKeys == 0) {
4645 buf = uw_Sqlcache_keyCopy(buf, keys[numKeys]); 4645 entry = cache->table;
4646 size_t len = buf - key;
4647 entry = uw_Sqlcache_find(cache, key, len, 1);
4648 if (!entry) { 4646 if (!entry) {
4649 free(key); 4647 free(key);
4650 pthread_rwlock_unlock(&cache->lock); 4648 pthread_rwlock_unlock(&cache->lock);
4651 return NULL; 4649 return NULL;
4652 } 4650 }
4653 timeInvalid = uw_Sqlcache_timeMax(timeInvalid, entry->timeInvalid); 4651 } else {
4654 } 4652 while (numKeys-- > 0) {
4655 free(key); 4653 buf = uw_Sqlcache_keyCopy(buf, keys[numKeys]);
4654 size_t len = buf - key;
4655 entry = uw_Sqlcache_find(cache, key, len, 1);
4656 if (!entry) {
4657 free(key);
4658 pthread_rwlock_unlock(&cache->lock);
4659 return NULL;
4660 }
4661 timeInvalid = uw_Sqlcache_timeMax(timeInvalid, entry->timeInvalid);
4662 }
4663 free(key);
4664 }
4656 // TODO: pass back copy of value and free it in the generated code... or use uw_malloc? 4665 // TODO: pass back copy of value and free it in the generated code... or use uw_malloc?
4657 uw_Sqlcache_Value *value = entry->value; 4666 uw_Sqlcache_Value *value = entry->value;
4658 pthread_rwlock_unlock(&cache->lock); 4667 pthread_rwlock_unlock(&cache->lock);
4659 return value && value->timeValid > timeInvalid ? value : NULL; 4668 return value && value->timeValid > timeInvalid ? value : NULL;
4660 } 4669 }
4664 size_t numKeys = cache->numKeys; 4673 size_t numKeys = cache->numKeys;
4665 char *key = uw_Sqlcache_allocKeyBuffer(keys, numKeys); 4674 char *key = uw_Sqlcache_allocKeyBuffer(keys, numKeys);
4666 char *buf = key; 4675 char *buf = key;
4667 time_t timeNow = uw_Sqlcache_getTimeNow(cache); 4676 time_t timeNow = uw_Sqlcache_getTimeNow(cache);
4668 uw_Sqlcache_Entry *entry; 4677 uw_Sqlcache_Entry *entry;
4669 while (numKeys-- > 0) { 4678 if (numKeys == 0) {
4670 buf = uw_Sqlcache_keyCopy(buf, keys[numKeys]); 4679 entry = cache->table;
4671 size_t len = buf - key;
4672 entry = uw_Sqlcache_find(cache, key, len, 1);
4673 if (!entry) { 4680 if (!entry) {
4674 entry = malloc(sizeof(uw_Sqlcache_Entry)); 4681 entry = malloc(sizeof(uw_Sqlcache_Entry));
4675 entry->key = strdup(key); 4682 entry->key = strdup(key);
4676 entry->value = NULL; 4683 entry->value = NULL;
4677 entry->timeInvalid = 0; 4684 entry->timeInvalid = 0;
4678 uw_Sqlcache_add(cache, entry, len); 4685 cache->table = entry;
4679 } 4686 }
4680 } 4687 } else {
4681 free(key); 4688 while (numKeys-- > 0) {
4689 buf = uw_Sqlcache_keyCopy(buf, keys[numKeys]);
4690 size_t len = buf - key;
4691 entry = uw_Sqlcache_find(cache, key, len, 1);
4692 if (!entry) {
4693 entry = malloc(sizeof(uw_Sqlcache_Entry));
4694 entry->key = strdup(key);
4695 entry->value = NULL;
4696 entry->timeInvalid = 0;
4697 uw_Sqlcache_add(cache, entry, len);
4698 }
4699 }
4700 free(key);
4701 }
4682 uw_Sqlcache_freeValue(entry->value); 4702 uw_Sqlcache_freeValue(entry->value);
4683 entry->value = value; 4703 entry->value = value;
4684 entry->value->timeValid = timeNow; 4704 entry->value->timeValid = timeNow;
4685 pthread_rwlock_unlock(&cache->lock); 4705 pthread_rwlock_unlock(&cache->lock);
4686 } 4706 }
4690 size_t numKeys = cache->numKeys; 4710 size_t numKeys = cache->numKeys;
4691 char *key = uw_Sqlcache_allocKeyBuffer(keys, numKeys); 4711 char *key = uw_Sqlcache_allocKeyBuffer(keys, numKeys);
4692 char *buf = key; 4712 char *buf = key;
4693 time_t timeNow = uw_Sqlcache_getTimeNow(cache); 4713 time_t timeNow = uw_Sqlcache_getTimeNow(cache);
4694 uw_Sqlcache_Entry *entry; 4714 uw_Sqlcache_Entry *entry;
4695 while (numKeys-- > 0) { 4715 if (numKeys == 0) {
4696 char *k = keys[numKeys]; 4716 puts("flush cache of height 0");
4697 if (!k) { 4717 entry = cache->table;
4698 if (entry) { 4718 if (entry) {
4699 entry->timeInvalid = timeNow; 4719 uw_Sqlcache_freeValue(entry->value);
4700 } else { 4720 entry->value = NULL;
4701 // Haven't found an entry yet, so the first key was null. 4721 }
4702 cache->timeInvalid = timeNow; 4722 } else {
4723 while (numKeys-- > 0) {
4724 char *k = keys[numKeys];
4725 if (!k) {
4726 if (entry) {
4727 entry->timeInvalid = timeNow;
4728 } else {
4729 // Haven't found an entry yet, so the first key was null.
4730 cache->timeInvalid = timeNow;
4731 }
4732 free(key);
4733 pthread_rwlock_unlock(&cache->lock);
4734 return;
4703 } 4735 }
4704 free(key); 4736 buf = uw_Sqlcache_keyCopy(buf, k);
4705 return; 4737 size_t len = buf - key;
4706 } 4738 entry = uw_Sqlcache_find(cache, key, len, 0);
4707 buf = uw_Sqlcache_keyCopy(buf, k); 4739 if (!entry) {
4708 size_t len = buf - key; 4740 free(key);
4709 entry = uw_Sqlcache_find(cache, key, len, 0); 4741 pthread_rwlock_unlock(&cache->lock);
4710 if (!entry) { 4742 return;
4711 free(key); 4743 }
4712 return; 4744 }
4713 } 4745 free(key);
4714 } 4746 // All the keys were non-null and the relevant entry is present, so we delete it.
4715 free(key); 4747 uw_Sqlcache_delete(cache, entry);
4716 // All the keys were non-null and the relevant entry is present, so we delete it. 4748 }
4717 uw_Sqlcache_delete(cache, entry);
4718 pthread_rwlock_unlock(&cache->lock); 4749 pthread_rwlock_unlock(&cache->lock);
4719 } 4750 }
4720 4751
4721 void uw_Sqlcache_freeUpdate(void *data, int dontCare) { 4752 void uw_Sqlcache_freeUpdate(void *data, int dontCare) {
4722 uw_context ctx = (uw_context)data; 4753 uw_context ctx = (uw_context)data;