int
main ()
{
random_t* random1Ptr;
random_t* random2Ptr;
random_t* random3Ptr;
long i;
puts("Starting...");
random1Ptr = random_alloc();
random2Ptr = random_alloc();
random3Ptr = random_alloc();
random_seed(random2Ptr, (RANDOM_DEFAULT_SEED + 1));
random_seed(random3Ptr, (RANDOM_DEFAULT_SEED + 1));
for (i = 0; i < NUM_ITERATIONS; i++) {
unsigned long rand1 = random_generate(random1Ptr);
unsigned long rand2 = random_generate(random2Ptr);
unsigned long rand3 = random_generate(random3Ptr);
printf("i = %2li, rand1 = %12lu, rand2 = %12lu, rand2 = %12lu\n",
i, rand1, rand2, rand3);
assert(rand1 != rand2);
assert(rand2 == rand3);
}
random_free(random1Ptr);
random_free(random2Ptr);
puts("Done.");
return 0;
}
/* =============================================================================
* queue_shuffle
* =============================================================================
*/
void
queue_shuffle (queue_t* queuePtr, random_t* randomPtr)
{
long pop = queuePtr->pop;
long push = queuePtr->push;
long capacity = queuePtr->capacity;
long numElement;
if (pop < push) {
numElement = push - (pop + 1);
} else {
numElement = capacity - (pop - push + 1);
}
void** elements = queuePtr->elements;
long i;
long base = pop + 1;
for (i = 0; i < numElement; i++) {
long r1 = random_generate(randomPtr) % numElement;
long r2 = random_generate(randomPtr) % numElement;
long i1 = (base + r1) % capacity;
long i2 = (base + r2) % capacity;
void* tmp = elements[i1];
elements[i1] = elements[i2];
elements[i2] = tmp;
}
}
/* =============================================================================
* initializeManager
* =============================================================================
*/
static manager_t*
initializeManager ()
{
manager_t* managerPtr;
long i;
long numRelation;
random_t* randomPtr;
long* ids;
bool_t (*manager_add[])(manager_t*, long, long, long) = {
&manager_addCar_seq,
&manager_addFlight_seq,
&manager_addRoom_seq,
&addCustomer
};
long t;
long numTable = sizeof(manager_add) / sizeof(manager_add[0]);
printf("Initializing manager... ");
fflush(stdout);
randomPtr = random_alloc();
managerPtr = manager_alloc();
numRelation = (long)global_params[PARAM_RELATIONS];
ids = (long*)malloc(numRelation * sizeof(long));
for (i = 0; i < numRelation; i++) {
ids[i] = i + 1;
}
for (t = 0; t < numTable; t++) {
/* Shuffle ids */
for (i = 0; i < numRelation; i++) {
long x = random_generate(randomPtr) % numRelation;
long y = random_generate(randomPtr) % numRelation;
long tmp = ids[x];
ids[x] = ids[y];
ids[y] = tmp;
}
/* Populate table */
for (i = 0; i < numRelation; i++) {
bool_t status;
long id = ids[i];
long num = ((random_generate(randomPtr) % 5) + 1) * 100;
long price = ((random_generate(randomPtr) % 5) * 10) + 50;
status = manager_add[t](managerPtr, id, num, price);
}
} /* for t */
puts("done.");
fflush(stdout);
random_free(randomPtr);
free(ids);
return managerPtr;
}
void random_seed(void)
{
s_clock clock;
t_uint64 rounds;
t_uint64 round;
assert(clock_current(&clock) == STATUS_OK);
_library_random_seed = CLOCK_UNIQUE(&clock);
rounds = random_generate() % 32;
for (round = 0; round < rounds; round++)
random_generate();
}
int fork_func(){
int fd[2], nbytes;
pid_t childpid;
int readbuffer[80];
pipe(fd);
if((childpid = fork()) == -1) {
perror("fork");
exit(1);
}
if(childpid == 0) {
/* Child process closes up input side of pipe */
close(fd[0]);
int result = random_generate((int)time(0));
/* Send "string" through the output side of pipe */
write(fd[1], &result, sizeof(result));
exit(0);
}
else {
/* Parent process closes up output side of pipe */
close(fd[1]);
/* Read in a string from the pipe */
nbytes = read(fd[0], readbuffer, sizeof(readbuffer));
printf("Received number: %d \n", readbuffer);
return readbuffer;
}
}
/**@brief Generate an appropriate, random Access Address following rules in
* Link Layer specification Section 2.1.2, Core 4.1 pages 2503-2504
*/
static uint32_t generate_access_address(void)
{
uint32_t aa = 0;
do {
for (int i = 0; i < 4; i++)
aa |= (random_generate() << (8*i));
} while (aa == LL_ACCESS_ADDRESS_ADV);
/* TODO: check for the various other requirements in the spec */
return aa;
}
int get_rand_level() {
int i, level = 1;
for (i = 0; i < levelmax - 1; i++) {
if ((random_generate(randomPtr) % 100) < 50)
level++;
else
break;
}
/* 1 <= level <= levelmax */
return level;
}
int get_random_integer( int min, int max)
{/* Init get_random_integer */
double y;
int ret;
y = random_generate();
ret = floor(((y * (max-min+1))));
return(min+ret);
#ifdef WRONG
int up = tabc[cl].card - 1;
return(GET_RANDOM_INTEGER(0,up));
#endif
}/* End get_random_integer */
/* =============================================================================
* net_generateRandomEdges
* =============================================================================
*/
void
net_generateRandomEdges (net_t* netPtr,
long maxNumParent,
long percentParent,
random_t* randomPtr)
{
vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;
long numNode = vector_getSize(nodeVectorPtr);
bitmap_t* visitedBitmapPtr = bitmap_alloc(numNode);
assert(visitedBitmapPtr);
queue_t* workQueuePtr = queue_alloc(-1);
long n;
for (n = 0; n < numNode; n++) {
long p;
for (p = 0; p < maxNumParent; p++) {
long value = random_generate(randomPtr) % 100;
if (value < percentParent) {
long parent = random_generate(randomPtr) % numNode;
if ((parent != n) &&
!net_hasEdge(netPtr, parent, n) &&
!net_isPath(netPtr, n, parent, visitedBitmapPtr, workQueuePtr))
{
#ifdef TEST_NET
printf("node=%li parent=%li\n", n, parent);
#endif
insertEdge(netPtr, parent, n);
}
}
}
}
assert(!net_isCycle(netPtr));
bitmap_free(visitedBitmapPtr);
queue_free(workQueuePtr);
}
int get_random_object( int cl )
{/* Init get_random_object */
double y;
int ret;
y = random_generate();
ret = floor(((y * (tabc[cl].card))));
return(ret);
#ifdef WRONG
int up = tabc[cl].card - 1;
return(GET_RANDOM_INTEGER(0,up));
#endif
}/* End get_random_object */
int mutation(int n)
{
int site = random_generate(MAX);
int i,j;
int array[MAX];
for(i=0; i<MAX;i++)
{
array[i] = n%2;
n = n/2;
}
Flip(array,site);
return decimal_convert(array);
cout<<endl;
}
/* =============================================================================
* splitIntoPackets
* -- Packets will be equal-size chunks except for last one, which will have
* all extra bytes
* =============================================================================
*/
static void
splitIntoPackets (char* str,
long flowId,
random_t* randomPtr,
vector_t* allocVectorPtr,
queue_t* packetQueuePtr)
{
long numByte = strlen(str);
long numPacket = random_generate(randomPtr) % numByte + 1;
long numDataByte = numByte / numPacket;
long p;
for (p = 0; p < (numPacket - 1); p++) {
bool_t status;
char* bytes = (char*)SEQ_MALLOC(PACKET_HEADER_LENGTH + numDataByte);
assert(bytes);
status = vector_pushBack(allocVectorPtr, (void*)bytes);
assert(status);
packet_t* packetPtr = (packet_t*)bytes;
packetPtr->flowId = flowId;
packetPtr->fragmentId = p;
packetPtr->numFragment = numPacket;
packetPtr->length = numDataByte;
memcpy(packetPtr->data, (str + p * numDataByte), numDataByte);
status = queue_push(packetQueuePtr, (void*)packetPtr);
assert(status);
}
bool_t status;
long lastNumDataByte = numDataByte + numByte % numPacket;
char* bytes = (char*)SEQ_MALLOC(PACKET_HEADER_LENGTH + lastNumDataByte);
assert(bytes);
status = vector_pushBack(allocVectorPtr, (void*)bytes);
assert(status);
packet_t* packetPtr = (packet_t*)bytes;
packetPtr->flowId = flowId;
packetPtr->fragmentId = p;
packetPtr->numFragment = numPacket;
packetPtr->length = lastNumDataByte;
memcpy(packetPtr->data, (str + p * numDataByte), lastNumDataByte);
status = queue_push(packetQueuePtr, (void*)packetPtr);
assert(status);
}
int do_random_gen(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
unsigned int seed,len,addr;
const char *cmd;
if (argc < 3)
goto usage;
cmd = argv[1];
if((strcmp(cmd,"gen")) && (strcmp(cmd,"read"))){
goto usage;
}
if(!strcmp(cmd,"gen")){
seed = simple_strtoul(argv[2], NULL, 16);
len = simple_strtoul(argv[3], NULL, 16);
if(argc >=5){
addr = simple_strtoul(argv[4], NULL, 16);
}
else{
addr = 0x82000000;
}
//seed += get_ticks();
if(len == 0){
len = 1;
}
if(random_generate(seed,(unsigned char *)addr,len) < 0){
printf("%s:%d,random generate fail\n",__func__,__LINE__);
return 1;
}
}
if(!strcmp(cmd,"read")){
printf("not support \n");
}
return 0;
usage:
cmd_usage(cmdtp);
return 1;
}
/* =============================================================================
* gene_create
* -- Populate contents with random gene
* =============================================================================
*/
void
gene_create (gene_t* genePtr, random_t* randomPtr)
{
long length;
char* contents;
long i;
const char nucleotides[] = {
NUCLEOTIDE_ADENINE,
NUCLEOTIDE_CYTOSINE,
NUCLEOTIDE_GUANINE,
NUCLEOTIDE_THYMINE,
};
assert(genePtr != NULL);
assert(randomPtr != NULL);
length = genePtr->length;
contents = genePtr->contents;
for (i = 0; i < length; i++) {
contents[i] =
nucleotides[(random_generate(randomPtr)% NUCLEOTIDE_NUM_TYPE)];
}
}
int main(int argc, char *argv[]){
//Déclaration des variables
int taille=0; //Taille des chaînes (change à chaque paramètre)
double min; //Temps minimum observé
double max; //Temps maximum observé
double sum; //Temps total depuis le début de l'execution (par paramètre)
double time;//Temps d'une execution
int cpt; //Compteur de génération
char* S=NULL; //Chaîne à comparer
char* T=NULL; //Idem
int (*pfonction)(char*,char*,const int &); //Pointeur de fonction (algo1,2,3)
std::ifstream fichier; //Pointeur du fichier en cour de lecture (paramètre)
int ligne_courante=0; //Second curseur (virtuel) dans le fichier
bool sortie; //Condition de sortie de boucle en lecture de fichier
int cpt_argument=2; //Compteur de l'argument en cours de lecture
int facteur; //On répète facteur fois le même test entre le début et la fin du chronomètre, pour obtenir un temps >1ms
//Attribution de l'algorithme en fonction du premier paramètre (1,2,3)
switch (atoi(argv[1])){
case 1 : pfonction=&algo1;break;
case 2 : pfonction=&algo2;break;
case 3 : pfonction=&algo3;break;
default : std::cout<<"Algorithm "<<atoi(argv[1])<<" does not exist !\n"; return 0;break;
}
//On parcourt chaque argument (demande de jeux de tests)
while(cpt_argument<argc)
{
//INITIALISATION DES VARIABLES
cpt=0;
min=200000000; //min doit être plus grand que 3minutes (en ms)
max=-1; //Valeur impossible (min=0)
time=0;
sum=0;
sortie=false;
//Si la taille est passée en paramètre (génération aléatoire)
if(atoi(argv[cpt_argument])!=0)
{
taille=atoi(argv[cpt_argument]);
//Génération aléatoire
S=random_generate(taille,cpt);
T=random_generate(taille,cpt+1);
facteur=1;
/*
* Boucle déterminant le facteur minimum à appliquer pour obtenir des chronométrages >1ms
*/
do{
//Lancement du chronomètre
crono_start();
for(int i=0;i<facteur;i++)
{
//On effectue facteur fois la résolution
(*pfonction)(S,T,taille);
}
crono_stop();
//Si le temps de résolution est inférieur à 5ms, on multiplie par 10 le facteur
if(crono_ms()<5)
{
facteur*=10;
}
}
while(crono_ms()<5);
/*
* Fin de la boucle de recherche de facteur
*/
//On génère des chaînes aléatoires jusqu'à 3 minutes de temps total de résolution
while(sum<180*1000)
{
//Génération aléatoire
S=random_generate(taille,cpt);
T=random_generate(taille,cpt+1);
//Lancement du chronomètre
crono_start();
for(int i=0;i<facteur;i++)
{
(*pfonction)(S,T,taille);
}
crono_stop();
//Mise à jour des statistiques
time=crono_ms();
sum+=time;
if(time>max)
{
max=time;
}
if(time<min)
{
min=time;
}
cpt+=2; //Voir fonction random_generate pour plus de détails
//Libération de S et T (cf random_generate)
free(S);
free(T);
}
}//boucle d'argument===taille
//Sinon, si un fichier est passé en paramètre
else
{
//Ouverture du fichier
fichier.open(argv[cpt_argument]);
//Contrôle de l'ouverture
if(fichier)
{
//Récupération de la taille des chaînes en première ligne
fichier>>taille;
S=(char*)malloc(taille*sizeof(char));
S[0]=' ';
T=(char*)malloc(taille*sizeof(char));
T[0]=' ';
//Récupération de la première chaine
fichier>>&S[1];
//Sauvegarde de la position (curseur virtuel)
ligne_courante=fichier.tellg();
//Recopie de S dans T pour la première comparaison
strcpy(T,S);
/*
* Détermination du facteur minimum
*/
facteur=1;
do{
crono_start();
for(int i=0;i<facteur;i++)
{
(*pfonction)(S,T,taille);
}
crono_stop();
//std::cout<<"facteur="<<facteur<<" crono="<<crono_ms()<<"\n";//@DEBUG
if(crono_ms()<5)
{
facteur*=10;
}
}
while(crono_ms()<5);
//Tant que toutes les chaînes n'ont pas été parcourues
while(!sortie)
{
//On résoud toutes les paires possibles du fichier
//Si le pointeur de "T" arrive à la fin du fichier
if(fichier.eof())
{
//On avance S d'une ligne
fichier.clear();
fichier.seekg(ligne_courante);
fichier>>&S[1];
strcpy(T,S);
//Condition d'arrêt du programme : les pointeurs S et T sont à la fin du fichier
if(fichier.eof())
{
sortie=true;break;
}
//On repart à partir de la ligne suivante
ligne_courante=fichier.tellg();
}
//Résolution
crono_start();
for(int i=0;i<facteur;i++)
{
(*pfonction)(S,T,taille);
}
crono_stop();
//Mise à jour des statistiques
time=crono_ms();
sum+=time;
if(time>max)
{
max=time;
}
if(time<min)
{
min=time;
}
cpt+=2;
fichier>>&T[1];
}
//On libère S et T uniquement à la fin
free(S);
free(T);
fichier.close();
}
else //ERREUR D'OUVERTURE DE FICHIER
{
std::cout<<"Wrong file input !\n";
return 0;
}
}//boucle d'argument===fichier
double negexp( double mean)
{/* Init negexp */
return(((double)(-log(random_generate())*((double)(mean)))));
}/* End negexp */
void client_run (void* argPtr) {
TM_THREAD_ENTER();
/*long id = thread_getId();
volatile long* ptr1 = &(global_array[0].value);
volatile long* ptr2 = &(global_array[100].value);
long tt = 0;
if (id == 0) {
while (1) {
long v1 = 0;
long v2 = 0;
acquire_write(&(local_th_data[phys_id]), &the_lock);
*ptr1 = (*ptr1) + 1;
int f = 1;
int ii;
for(ii = 1; ii <= 100000000; ii++)
{
f *= ii;
}
tt += f;
*ptr2 = (*ptr2) + 1;
v1 = global_array[0].value;
v2 = global_array[100].value;
release_write(cluster_id, &(local_th_data[phys_id]), &the_lock); \
if (v1 != v2) {
printf("different2! %ld %ld\n", v1, v2);
exit(1);
}
}
} else {
while (1) {
int i = 0;
long sum = 0;
for (; i < 100000; i++) {
int status = _xbegin();
if (status == _XBEGIN_STARTED) {
sum += *ptr1;
sum += *ptr2;
_xend();
}
}
while(1) {
long v1 = 0;
long v2 = 0;
int status = _xbegin();
if (status == _XBEGIN_STARTED) {
v1 = *ptr1;
v2 = *ptr2;
_xend();
if (v1 != v2) {
printf("different! %ld %ld\n", v1, v2);
exit(1);
}
}
}
}
}
printf("%ld", tt);*/
random_t* randomPtr = random_alloc();
random_seed(randomPtr, time(0));
// unsigned long myId = thread_getId();
// long numThread = *((long*)argPtr);
long operations = (long)global_params[PARAM_OPERATIONS] / (long)global_params[PARAM_THREADS];
long interval = (long)global_params[PARAM_INTERVAL];
printf("operations: %ld \tinterval: %ld\n", operations, interval);
long total = 0;
long total2 = 0;
long i = 0;
for (; i < operations; i++) {
long random_number = ((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE]);
long random_number2 = ((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE]);
if (random_number == random_number2) {
random_number2 = (random_number2 + 1) % ((long)global_params[PARAM_SIZE]);
}
TM_BEGIN();
long r1 = (long)TM_SHARED_READ_L(global_array[random_number].value);
long r2 = (long)TM_SHARED_READ_L(global_array[random_number2].value);
int repeat = 0;
for (; repeat < (long) global_params[PARAM_CONTENTION]; repeat++) {
total2 += (long) TM_SHARED_READ_L(global_array[((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE])].value);
}
r1 = r1 + 1;
r2 = r2 - 1;
int f = 1;
int ii;
for(ii = 1; ii <= ((unsigned int) global_params[PARAM_WORK]); ii++)
{
f *= ii;
}
total += f / 1000000;
TM_SHARED_WRITE_L(global_array[random_number].value, r1);
TM_SHARED_WRITE_L(global_array[random_number2].value, r2);
TM_END();
long k = 0;
for (;k < (long)global_params[PARAM_INTERVAL]; k++) {
long ru = ((long) random_generate(randomPtr)) % 2;
total += ru;
}
}
TM_THREAD_EXIT();
printf("ru ignore %ld - %ld\n", total, total2);
}
void client_run (void* argPtr) {
TM_THREAD_ENTER();
random_t* randomPtr = random_alloc();
random_seed(randomPtr, time(0));
// unsigned long myId = thread_getId();
// long numThread = *((long*)argPtr);
long operations = (long)global_params[PARAM_OPERATIONS] / (long)global_params[PARAM_THREADS];
long interval = (long)global_params[PARAM_INTERVAL];
printf("operations: %ld \tinterval: %ld\n", operations, interval);
long total = 0;
long total2 = 0;
long i = 0;
unsigned int cont_size = (unsigned int) global_params[PARAM_CONTENTION];
unsigned int* sorted_locks = (unsigned int*) malloc((2 + cont_size) * sizeof(int));
unsigned int* read_idxs = (unsigned int*) malloc(cont_size * sizeof(int));
for (; i < operations; i++) {
long random_number = ((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE]);
long random_number2 = ((long) random_generate(randomPtr)) % ((long)global_params[PARAM_SIZE]);
if (random_number == random_number2) {
random_number2 = (random_number2 + 1) % ((long)global_params[PARAM_SIZE]);
}
int repeat = 0;
for (; repeat < cont_size; repeat++) {
read_idxs[repeat] = ((unsigned int) random_generate(randomPtr)) % ((unsigned int)global_params[PARAM_SIZE]);
LI_HASH(&global_array[read_idxs[repeat]], &sorted_locks[repeat + 2]);
}
// TM_BEGIN();
LI_HASH(&global_array[random_number], &sorted_locks[0]);
LI_HASH(&global_array[random_number2], &sorted_locks[1]);
TM_BEGIN_ARGS(sorted_locks, cont_size + 2);
long r1 = (long)TM_SHARED_READ(global_array[random_number].value);
long r2 = (long)TM_SHARED_READ(global_array[random_number2].value);
for (repeat--; repeat >= 0; repeat--) {
total2 += (long) TM_SHARED_READ(global_array[read_idxs[repeat]].value);
}
r1 = r1 + 1;
r2 = r2 - 1;
int f = 1;
int ii;
for(ii = 1; ii <= ((unsigned int) global_params[PARAM_WORK]); ii++)
{
f *= ii;
}
total += f / 1000000;
TM_SHARED_WRITE(global_array[random_number].value, r1);
TM_SHARED_WRITE(global_array[random_number2].value, r2);
TM_END_ARGS(sorted_locks, cont_size + 2);
long k = 0;
for (;k < (long)global_params[PARAM_INTERVAL]; k++) {
long ru = ((long) random_generate(randomPtr)) % 2;
total += ru;
}
}
TM_THREAD_EXIT();
printf("ru ignore %ld - %ld\n", total, total2);
}
/* =============================================================================
* genScalData_seq
* =============================================================================
*/
void
genScalData_seq (graphSDG* SDGdataPtr)
{
/*
* STEP 0: Create the permutations required to randomize the vertices
*/
random_t* stream = random_alloc();
assert(stream);
random_seed(stream, 0);
ULONGINT_T* permV; /* the vars associated with the graph tuple */
permV = (ULONGINT_T*)malloc(TOT_VERTICES * sizeof(ULONGINT_T));
assert(permV);
long i;
/* Initialize the array */
for (i = 0; i < TOT_VERTICES; i++) {
permV[i] = i;
}
for (i = 0; i < TOT_VERTICES; i++) {
long t1 = random_generate(stream);
long t = i + t1 % (TOT_VERTICES - i);
if (t != i) {
ULONGINT_T t2 = permV[t];
permV[t] = permV[i];
permV[i] = t2;
}
}
/*
* STEP 1: Create Cliques
*/
long* cliqueSizes;
long estTotCliques = ceil(1.5 * TOT_VERTICES / ((1+MAX_CLIQUE_SIZE)/2));
/*
* Allocate mem for Clique array
* Estimate number of clique required and pad by 50%
*/
cliqueSizes = (long*)malloc(estTotCliques * sizeof(long));
assert(cliqueSizes);
/* Generate random clique sizes. */
for (i = 0; i < estTotCliques; i++) {
cliqueSizes[i] = 1 + (random_generate(stream) % MAX_CLIQUE_SIZE);
}
long totCliques = 0;
/*
* Allocate memory for cliqueList
*/
ULONGINT_T* lastVsInCliques;
ULONGINT_T* firstVsInCliques;
lastVsInCliques = (ULONGINT_T*)malloc(estTotCliques * sizeof(ULONGINT_T));
assert(lastVsInCliques);
firstVsInCliques = (ULONGINT_T*)malloc(estTotCliques * sizeof(ULONGINT_T));
assert(firstVsInCliques);
/*
* Sum up vertices in each clique to determine the lastVsInCliques array
*/
lastVsInCliques[0] = cliqueSizes[0] - 1;
for (i = 1; i < estTotCliques; i++) {
lastVsInCliques[i] = cliqueSizes[i] + lastVsInCliques[i-1];
if (lastVsInCliques[i] >= TOT_VERTICES-1) {
break;
}
}
totCliques = i + 1;
/*
* Fix the size of the last clique
*/
cliqueSizes[totCliques-1] =
TOT_VERTICES - lastVsInCliques[totCliques-2] - 1;
lastVsInCliques[totCliques-1] = TOT_VERTICES - 1;
firstVsInCliques[0] = 0;
/*
* Compute start Vertices in cliques.
*/
for (i = 1; i < totCliques; i++) {
firstVsInCliques[i] = lastVsInCliques[i-1] + 1;
}
#ifdef WRITE_RESULT_FILES
/* Write the generated cliques to file for comparison with Kernel 4 */
FILE* outfp = fopen("cliques.txt", "w");
fprintf(outfp, "No. of cliques - %lu\n", totCliques);
for (i = 0; i < totCliques; i++) {
fprintf(outfp, "Clq %lu - ", i);
long j;
for (j = firstVsInCliques[i]; j <= lastVsInCliques[i]; j++) {
fprintf(outfp, "%lu ", permV[j]);
}
fprintf(outfp, "\n");
}
fclose(outfp);
#endif
/*
* STEP 2: Create the edges within the cliques
*/
/*
* Estimate number of edges - using an empirical measure
*/
long estTotEdges;
if (SCALE >= 12) {
estTotEdges = ceil(((MAX_CLIQUE_SIZE-1) * TOT_VERTICES));
} else {
estTotEdges = ceil(1.2 * (((MAX_CLIQUE_SIZE-1)*TOT_VERTICES)
* ((1 + MAX_PARAL_EDGES)/2) + TOT_VERTICES*2));
}
/*
* Initialize edge counter
*/
long i_edgePtr = 0;
float p = PROB_UNIDIRECTIONAL;
/*
* Partial edgeLists
*/
ULONGINT_T* startV;
ULONGINT_T* endV;
long numByte = (estTotEdges) * sizeof(ULONGINT_T);
startV = (ULONGINT_T*)malloc(numByte);
endV = (ULONGINT_T*)malloc(numByte);
assert(startV);
assert(endV);
/*
* Tmp array to keep track of the no. of parallel edges in each direction
*/
ULONGINT_T** tmpEdgeCounter =
(ULONGINT_T**)malloc(MAX_CLIQUE_SIZE * sizeof(ULONGINT_T *));
assert(tmpEdgeCounter);
for (i = 0; i < MAX_CLIQUE_SIZE; i++) {
tmpEdgeCounter[i] =
(ULONGINT_T*)malloc(MAX_CLIQUE_SIZE * sizeof(ULONGINT_T));
assert(tmpEdgeCounter[i]);
}
/*
* Create edges
*/
long i_clique;
for (i_clique = 0; i_clique < totCliques; i_clique++) {
/*
* Get current clique parameters
*/
long i_cliqueSize = cliqueSizes[i_clique];
long i_firstVsInClique = firstVsInCliques[i_clique];
/*
* First create at least one edge between two vetices in a clique
*/
for (i = 0; i < i_cliqueSize; i++) {
long j;
for (j = 0; j < i; j++) {
float r = (float)(random_generate(stream) % 1000) / (float)1000;
if (r >= p) {
startV[i_edgePtr] = i + i_firstVsInClique;
endV[i_edgePtr] = j + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[i][j] = 1;
startV[i_edgePtr] = j + i_firstVsInClique;
endV[i_edgePtr] = i + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[j][i] = 1;
} else if (r >= 0.5) {
startV[i_edgePtr] = i + i_firstVsInClique;
endV[i_edgePtr] = j + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[i][j] = 1;
tmpEdgeCounter[j][i] = 0;
} else {
startV[i_edgePtr] = j + i_firstVsInClique;
endV[i_edgePtr] = i + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[j][i] = 1;
tmpEdgeCounter[i][j] = 0;
}
} /* for j */
} /* for i */
if (i_cliqueSize != 1) {
long randNumEdges = (long)(random_generate(stream)
% (2*i_cliqueSize*MAX_PARAL_EDGES));
long i_paralEdge;
for (i_paralEdge = 0; i_paralEdge < randNumEdges; i_paralEdge++) {
i = (random_generate(stream) % i_cliqueSize);
long j = (random_generate(stream) % i_cliqueSize);
if ((i != j) && (tmpEdgeCounter[i][j] < MAX_PARAL_EDGES)) {
float r = (float)(random_generate(stream) % 1000) / (float)1000;
if (r >= p) {
/* Copy to edge structure. */
startV[i_edgePtr] = i + i_firstVsInClique;
endV[i_edgePtr] = j + i_firstVsInClique;
i_edgePtr++;
tmpEdgeCounter[i][j]++;
}
}
}
}
} /* for i_clique */
for (i = 0; i < MAX_CLIQUE_SIZE; i++) {
free(tmpEdgeCounter[i]);
}
free(tmpEdgeCounter);
/*
* Merge partial edge lists
*/
ULONGINT_T i_edgeStartCounter = 0;
ULONGINT_T i_edgeEndCounter = i_edgePtr;
long edgeNum = i_edgePtr;
/*
* Initialize edge list arrays
*/
ULONGINT_T* startVertex;
ULONGINT_T* endVertex;
if (SCALE < 10) {
long numByte = 2 * edgeNum * sizeof(ULONGINT_T);
startVertex = (ULONGINT_T*)malloc(numByte);
endVertex = (ULONGINT_T*)malloc(numByte);
} else {
long numByte = (edgeNum + MAX_PARAL_EDGES * TOT_VERTICES)
* sizeof(ULONGINT_T);
startVertex = (ULONGINT_T*)malloc(numByte);
endVertex = (ULONGINT_T*)malloc(numByte);
}
assert(startVertex);
assert(endVertex);
for (i = i_edgeStartCounter; i < i_edgeEndCounter; i++) {
startVertex[i] = startV[i-i_edgeStartCounter];
endVertex[i] = endV[i-i_edgeStartCounter];
}
ULONGINT_T numEdgesPlacedInCliques = edgeNum;
/*
* STEP 3: Connect the cliques
*/
i_edgePtr = 0;
p = PROB_INTERCL_EDGES;
/*
* Generating inter-clique edges as given in the specs
*/
for (i = 0; i < TOT_VERTICES; i++) {
ULONGINT_T tempVertex1 = i;
long h = totCliques;
long l = 0;
long t = -1;
while (h - l > 1) {
long m = (h + l) / 2;
if (tempVertex1 >= firstVsInCliques[m]) {
l = m;
} else {
if ((tempVertex1 < firstVsInCliques[m]) && (m > 0)) {
if (tempVertex1 >= firstVsInCliques[m-1]) {
t = m - 1;
break;
} else {
h = m;
}
}
}
}
if (t == -1) {
long m;
for (m = (l + 1); m < h; m++) {
if (tempVertex1<firstVsInCliques[m]) {
break;
}
}
t = m-1;
}
long t1 = firstVsInCliques[t];
ULONGINT_T d;
for (d = 1, p = PROB_INTERCL_EDGES; d < TOT_VERTICES; d *= 2, p /= 2) {
float r = (float)(random_generate(stream) % 1000) / (float)1000;
if (r <= p) {
ULONGINT_T tempVertex2 = (i+d) % TOT_VERTICES;
h = totCliques;
l = 0;
t = -1;
while (h - l > 1) {
long m = (h + l) / 2;
if (tempVertex2 >= firstVsInCliques[m]) {
l = m;
} else {
if ((tempVertex2 < firstVsInCliques[m]) && (m > 0)) {
if (firstVsInCliques[m-1] <= tempVertex2) {
t = m - 1;
break;
} else {
h = m;
}
}
}
}
if (t == -1) {
long m;
for (m = (l + 1); m < h; m++) {
if (tempVertex2 < firstVsInCliques[m]) {
break;
}
}
t = m - 1;
}
long t2 = firstVsInCliques[t];
if (t1 != t2) {
long randNumEdges =
random_generate(stream) % MAX_PARAL_EDGES + 1;
long j;
for (j = 0; j < randNumEdges; j++) {
startV[i_edgePtr] = tempVertex1;
endV[i_edgePtr] = tempVertex2;
i_edgePtr++;
}
}
} /* r <= p */
float r0 = (float)(random_generate(stream) % 1000) / (float)1000;
if ((r0 <= p) && (i-d>=0)) {
ULONGINT_T tempVertex2 = (i-d) % TOT_VERTICES;
h = totCliques;
l = 0;
t = -1;
while (h - l > 1) {
long m = (h + l) / 2;
if (tempVertex2 >= firstVsInCliques[m]) {
l = m;
} else {
if ((tempVertex2 < firstVsInCliques[m]) && (m > 0)) {
if (firstVsInCliques[m-1] <= tempVertex2) {
t = m - 1;
break;
} else {
h = m;
}
}
}
}
if (t == -1) {
long m;
for (m = (l + 1); m < h; m++) {
if (tempVertex2 < firstVsInCliques[m]) {
break;
}
}
t = m - 1;
}
long t2 = firstVsInCliques[t];
if (t1 != t2) {
long randNumEdges =
random_generate(stream) % MAX_PARAL_EDGES + 1;
long j;
for (j = 0; j < randNumEdges; j++) {
startV[i_edgePtr] = tempVertex1;
endV[i_edgePtr] = tempVertex2;
i_edgePtr++;
}
}
} /* r0 <= p && (i-d) > 0 */
} /* for d, p */
} /* for i */
i_edgeEndCounter = i_edgePtr;
i_edgeStartCounter = 0;
edgeNum = i_edgePtr;
ULONGINT_T numEdgesPlacedOutside = edgeNum;
for (i = i_edgeStartCounter; i < i_edgeEndCounter; i++) {
startVertex[i+numEdgesPlacedInCliques] = startV[i-i_edgeStartCounter];
endVertex[i+numEdgesPlacedInCliques] = endV[i-i_edgeStartCounter];
}
ULONGINT_T numEdgesPlaced = numEdgesPlacedInCliques + numEdgesPlacedOutside;
SDGdataPtr->numEdgesPlaced = numEdgesPlaced;
printf("Finished generating edges\n");
printf("No. of intra-clique edges - %lu\n", numEdgesPlacedInCliques);
printf("No. of inter-clique edges - %lu\n", numEdgesPlacedOutside);
printf("Total no. of edges - %lu\n", numEdgesPlaced);
free(cliqueSizes);
free(firstVsInCliques);
free(lastVsInCliques);
free(startV);
free(endV);
/*
* STEP 4: Generate edge weights
*/
SDGdataPtr->intWeight =
(LONGINT_T*)malloc(numEdgesPlaced * sizeof(LONGINT_T));
assert(SDGdataPtr->intWeight);
p = PERC_INT_WEIGHTS;
ULONGINT_T numStrWtEdges = 0;
for (i = 0; i < numEdgesPlaced; i++) {
float r = (float)(random_generate(stream) % 1000) / (float)1000;
if (r <= p) {
SDGdataPtr->intWeight[i] =
1 + (random_generate(stream) % (MAX_INT_WEIGHT-1));
} else {
SDGdataPtr->intWeight[i] = -1;
numStrWtEdges++;
}
}
long t = 0;
for (i = 0; i < numEdgesPlaced; i++) {
if (SDGdataPtr->intWeight[i] < 0) {
SDGdataPtr->intWeight[i] = -t;
t++;
}
}
SDGdataPtr->strWeight =
(char*)malloc(numStrWtEdges * MAX_STRLEN * sizeof(char));
assert(SDGdataPtr->strWeight);
for (i = 0; i < numEdgesPlaced; i++) {
if (SDGdataPtr->intWeight[i] <= 0) {
long j;
for (j = 0; j < MAX_STRLEN; j++) {
SDGdataPtr->strWeight[(-SDGdataPtr->intWeight[i])*MAX_STRLEN+j] =
(char) (1 + random_generate(stream) % 127);
}
}
}
/*
* Choose SOUGHT STRING randomly if not assigned
*/
if (strlen(SOUGHT_STRING) != MAX_STRLEN) {
SOUGHT_STRING = (char*)malloc(MAX_STRLEN * sizeof(char));
assert(SOUGHT_STRING);
}
t = random_generate(stream) % numStrWtEdges;
long j;
for (j = 0; j < MAX_STRLEN; j++) {
SOUGHT_STRING[j] =
(char) ((long) SDGdataPtr->strWeight[t*MAX_STRLEN+j]);
}
/*
* STEP 5: Permute Vertices
*/
for (i = 0; i < numEdgesPlaced; i++) {
startVertex[i] = permV[(startVertex[i])];
endVertex[i] = permV[(endVertex[i])];
}
/*
* STEP 6: Sort Vertices
*/
/*
* Radix sort with StartVertex as primary key
*/
numByte = numEdgesPlaced * sizeof(ULONGINT_T);
SDGdataPtr->startVertex = (ULONGINT_T*)malloc(numByte);
assert(SDGdataPtr->startVertex);
SDGdataPtr->endVertex = (ULONGINT_T*)malloc(numByte);
assert(SDGdataPtr->endVertex);
all_radixsort_node_aux_s3_seq(numEdgesPlaced,
startVertex,
SDGdataPtr->startVertex,
endVertex,
SDGdataPtr->endVertex);
free(startVertex);
free(endVertex);
if (SCALE < 12) {
/*
* Sort with endVertex as secondary key
*/
long i0 = 0;
long i1 = 0;
i = 0;
while (i < numEdgesPlaced) {
for (i = i0; i < numEdgesPlaced; i++) {
if (SDGdataPtr->startVertex[i] !=
SDGdataPtr->startVertex[i1])
{
i1 = i;
break;
}
}
long j;
for (j = i0; j < i1; j++) {
long k;
for (k = j+1; k < i1; k++) {
if (SDGdataPtr->endVertex[k] <
SDGdataPtr->endVertex[j])
{
long t = SDGdataPtr->endVertex[j];
SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k];
SDGdataPtr->endVertex[k] = t;
}
}
}
if (SDGdataPtr->startVertex[i0] != TOT_VERTICES-1) {
i0 = i1;
} else {
long j;
for (j=i0; j<numEdgesPlaced; j++) {
long k;
for (k=j+1; k<numEdgesPlaced; k++) {
if (SDGdataPtr->endVertex[k] <
SDGdataPtr->endVertex[j])
{
long t = SDGdataPtr->endVertex[j];
SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k];
SDGdataPtr->endVertex[k] = t;
}
}
}
}
} /* while i < numEdgesPlaced */
} else {
ULONGINT_T* tempIndex =
(ULONGINT_T*)malloc((TOT_VERTICES + 1) * sizeof(ULONGINT_T));
/*
* Update degree of each vertex
*/
tempIndex[0] = 0;
tempIndex[TOT_VERTICES] = numEdgesPlaced;
long i0 = 0;
for (i=0; i < TOT_VERTICES; i++) {
tempIndex[i+1] = tempIndex[i];
long j;
for (j = i0; j < numEdgesPlaced; j++) {
if (SDGdataPtr->startVertex[j] !=
SDGdataPtr->startVertex[i0])
{
if (SDGdataPtr->startVertex[i0] == i) {
tempIndex[i+1] = j;
i0 = j;
break;
}
}
}
}
/*
* Insertion sort for now, replace with something better later on
*/
for (i = 0; i < TOT_VERTICES; i++) {
long j;
for (j = tempIndex[i]; j < tempIndex[i+1]; j++) {
long k;
for (k = (j + 1); k < tempIndex[i+1]; k++) {
if (SDGdataPtr->endVertex[k] <
SDGdataPtr->endVertex[j])
{
long t = SDGdataPtr->endVertex[j];
SDGdataPtr->endVertex[j] = SDGdataPtr->endVertex[k];
SDGdataPtr->endVertex[k] = t;
}
}
}
}
free(tempIndex);
} /* SCALE >= 12 */
random_free(stream);
free(permV);
}
/* =============================================================================
* segments_create
* -- Populates 'contentsPtr'
* =============================================================================
*/
void
segments_create (segments_t* segmentsPtr, gene_t* genePtr, random_t* randomPtr)
{
vector_t* segmentsContentsPtr;
char** strings;
long segmentLength;
long minNumSegment;
char* geneString;
long geneLength;
bitmap_t* startBitmapPtr;
long numStart;
long i;
long maxZeroRunLength;
assert(segmentsPtr != NULL);
assert(genePtr != NULL);
assert(randomPtr != NULL);
segmentsContentsPtr = segmentsPtr->contentsPtr;
strings = segmentsPtr->strings;
segmentLength = segmentsPtr->length;
minNumSegment = segmentsPtr->minNum;
geneString = genePtr->contents;
geneLength = genePtr->length;
startBitmapPtr = genePtr->startBitmapPtr;
numStart = geneLength - segmentLength + 1;
/* Pick some random segments to start */
for (i = 0; i < minNumSegment; i++) {
long j = (long)(random_generate(randomPtr) % numStart);
bool_t status = bitmap_set(startBitmapPtr, j);
assert(status);
memcpy(strings[i], &(geneString[j]), segmentLength * sizeof(char));
status = vector_pushBack(segmentsContentsPtr, (void*)strings[i]);
assert(status);
}
/* Make sure segment covers start */
i = 0;
if (!bitmap_isSet(startBitmapPtr, i)) {
char* string = (char*)malloc((segmentLength+1) * sizeof(char));
string[segmentLength] = '\0';
memcpy(string, &(geneString[i]), segmentLength * sizeof(char));
bool_t status = vector_pushBack(segmentsContentsPtr, (void*)string);
assert(status);
status = bitmap_set(startBitmapPtr, i);
assert(status);
}
/* Add extra segments to fill holes and ensure overlap */
maxZeroRunLength = segmentLength - 1;
for (i = 0; i < numStart; i++) {
long i_stop = MIN((i+maxZeroRunLength), numStart);
for ( /* continue */; i < i_stop; i++) {
if (bitmap_isSet(startBitmapPtr, i)) {
break;
}
}
if (i == i_stop) {
/* Found big enough hole */
char* string = (char*)malloc((segmentLength+1) * sizeof(char));
string[segmentLength] = '\0';
i = i - 1;
memcpy(string, &(geneString[i]), segmentLength * sizeof(char));
bool_t status = vector_pushBack(segmentsContentsPtr, (void*)string);
assert(status);
status = bitmap_set(startBitmapPtr, i);
assert(status);
}
}
}
/* =============================================================================
* stream_generate
* -- Returns number of attacks generated
* =============================================================================
*/
long
stream_generate (stream_t* streamPtr,
dictionary_t* dictionaryPtr,
long numFlow,
long seed,
long maxLength)
{
long numAttack = 0;
long percentAttack = streamPtr->percentAttack;
random_t* randomPtr = streamPtr->randomPtr;
vector_t* allocVectorPtr = streamPtr->allocVectorPtr;
queue_t* packetQueuePtr = streamPtr->packetQueuePtr;
MAP_T* attackMapPtr = streamPtr->attackMapPtr;
detector_t* detectorPtr = detector_alloc();
detector_addPreprocessor(detectorPtr, &preprocessor_toLower);
random_seed(randomPtr, seed);
queue_clear(packetQueuePtr);
long range = '~' - ' ' + 1;
long f;
for (f = 1; f <= numFlow; f++) {
char* str;
if ((random_generate(randomPtr) % 100) < percentAttack) {
long s = random_generate(randomPtr) % global_numDefaultSignature;
str = dictionary_get(dictionaryPtr, s);
bool_t status =
MAP_INSERT(attackMapPtr, (void*)f, (void*)str);
numAttack++;
} else {
/*
* Create random string
*/
long length = (random_generate(randomPtr) % maxLength) + 1;
str = (char*)malloc((length + 1) * sizeof(char));
bool_t status = vector_pushBack(allocVectorPtr, (void*)str);
long l;
for (l = 0; l < length; l++) {
str[l] = ' ' + (char)(random_generate(randomPtr) % range);
}
str[l] = '\0';
char* str2 = (char*)malloc((length + 1) * sizeof(char));
strcpy(str2, str);
error_t error = detector_process(detectorPtr, str2); /* updates in-place */
if (error == ERROR_SIGNATURE) {
bool_t status = MAP_INSERT(attackMapPtr,
(void*)f,
(void*)str);
numAttack++;
}
free(str2);
}
splitIntoPackets(str, f, randomPtr, allocVectorPtr, packetQueuePtr);
}
queue_shuffle(packetQueuePtr, randomPtr);
detector_free(detectorPtr);
return numAttack;
}
/* =============================================================================
* data_generate
* -- Binary variables of random PDFs
* -- If seed is <0, do not reseed
* -- Returns random network
* =============================================================================
*/
net_t*
data_generate (data_t* dataPtr, long seed, long maxNumParent, long percentParent)
{
random_t* randomPtr = dataPtr->randomPtr;
if (seed >= 0) {
random_seed(randomPtr, seed);
}
/*
* Generate random Bayesian network
*/
long numVar = dataPtr->numVar;
net_t* netPtr = net_alloc(numVar);
assert(netPtr);
net_generateRandomEdges(netPtr, maxNumParent, percentParent, randomPtr);
/*
* Create a threshold for each of the possible permutation of variable
* value instances
*/
long** thresholdsTable = (long**)SEQ_MALLOC(numVar * sizeof(long*));
assert(thresholdsTable);
long v;
for (v = 0; v < numVar; v++) {
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, v);
long numThreshold = 1 << list_getSize(parentIdListPtr);
long* thresholds = (long*)SEQ_MALLOC(numThreshold * sizeof(long));
assert(thresholds);
long t;
for (t = 0; t < numThreshold; t++) {
long threshold = random_generate(randomPtr) % (DATA_PRECISION + 1);
thresholds[t] = threshold;
}
thresholdsTable[v] = thresholds;
}
/*
* Create variable dependency ordering for record generation
*/
long* order = (long*)SEQ_MALLOC(numVar * sizeof(long));
assert(order);
long numOrder = 0;
queue_t* workQueuePtr = queue_alloc(-1);
assert(workQueuePtr);
vector_t* dependencyVectorPtr = vector_alloc(1);
assert(dependencyVectorPtr);
bitmap_t* orderedBitmapPtr = bitmap_alloc(numVar);
assert(orderedBitmapPtr);
bitmap_clearAll(orderedBitmapPtr);
bitmap_t* doneBitmapPtr = bitmap_alloc(numVar);
assert(doneBitmapPtr);
bitmap_clearAll(doneBitmapPtr);
v = -1;
while ((v = bitmap_findClear(doneBitmapPtr, (v + 1))) >= 0) {
list_t* childIdListPtr = net_getChildIdListPtr(netPtr, v);
long numChild = list_getSize(childIdListPtr);
if (numChild == 0) {
bool status;
/*
* Use breadth-first search to find net connected to this leaf
*/
queue_clear(workQueuePtr);
status = queue_push(workQueuePtr, (void*)v);
assert(status);
while (!queue_isEmpty(workQueuePtr)) {
long id = (long)queue_pop(workQueuePtr);
status = bitmap_set(doneBitmapPtr, id);
assert(status);
status = vector_pushBack(dependencyVectorPtr, (void*)id);
assert(status);
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, id);
list_iter_t it;
list_iter_reset(&it, parentIdListPtr);
while (list_iter_hasNext(&it, parentIdListPtr)) {
long parentId = (long)list_iter_next(&it, parentIdListPtr);
status = queue_push(workQueuePtr, (void*)parentId);
assert(status);
}
}
/*
* Create ordering
*/
long i;
long n = vector_getSize(dependencyVectorPtr);
for (i = 0; i < n; i++) {
long id = (long)vector_popBack(dependencyVectorPtr);
if (!bitmap_isSet(orderedBitmapPtr, id)) {
bitmap_set(orderedBitmapPtr, id);
order[numOrder++] = id;
}
}
}
}
assert(numOrder == numVar);
/*
* Create records
*/
char* record = dataPtr->records;
long r;
long numRecord = dataPtr->numRecord;
for (r = 0; r < numRecord; r++) {
long o;
for (o = 0; o < numOrder; o++) {
long v = order[o];
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, v);
long index = 0;
list_iter_t it;
list_iter_reset(&it, parentIdListPtr);
while (list_iter_hasNext(&it, parentIdListPtr)) {
long parentId = (long)list_iter_next(&it, parentIdListPtr);
long value = record[parentId];
assert(value != DATA_INIT);
index = (index << 1) + value;
}
long rnd = random_generate(randomPtr) % DATA_PRECISION;
long threshold = thresholdsTable[v][index];
record[v] = ((rnd < threshold) ? 1 : 0);
}
record += numVar;
assert(record <= (dataPtr->records + numRecord * numVar));
}
/*
* Clean up
*/
bitmap_free(doneBitmapPtr);
bitmap_free(orderedBitmapPtr);
vector_free(dependencyVectorPtr);
queue_free(workQueuePtr);
SEQ_FREE(order);
for (v = 0; v < numVar; v++) {
SEQ_FREE(thresholdsTable[v]);
}
SEQ_FREE(thresholdsTable);
return netPtr;
}
void One_point_mutation(int Population[])
{
int member = random_generate(POP);
mutation(Population[member]);
}
/* =============================================================================
* client_run
* -- Execute list operations on the database
* =============================================================================
*/
void
client_run (void* argPtr)
{
TM_THREAD_ENTER();
long myId = thread_getId();
client_t* clientPtr = ((client_t**)argPtr)[myId];
manager_t* managerPtr = clientPtr->managerPtr;
random_t* randomPtr = clientPtr->randomPtr;
long numOperation = clientPtr->numOperation;
long numQueryPerTransaction = clientPtr->numQueryPerTransaction;
long queryRange = clientPtr->queryRange;
long percentUser = clientPtr->percentUser;
long* types = (long*)P_MALLOC(numQueryPerTransaction * sizeof(long));
long* ids = (long*)P_MALLOC(numQueryPerTransaction * sizeof(long));
long* ops = (long*)P_MALLOC(numQueryPerTransaction * sizeof(long));
long* prices = (long*)P_MALLOC(numQueryPerTransaction * sizeof(long));
long i;
for (i = 0; i < numOperation; i++) {
long r = random_generate(randomPtr) % 100;
action_t action = selectAction(r, percentUser);
switch (action) {
case ACTION_MAKE_RESERVATION: {
long maxPrices[NUM_RESERVATION_TYPE] = { -1, -1, -1 };
long maxIds[NUM_RESERVATION_TYPE] = { -1, -1, -1 };
long n;
long numQuery = random_generate(randomPtr) % numQueryPerTransaction + 1;
long customerId = random_generate(randomPtr) % queryRange + 1;
for (n = 0; n < numQuery; n++) {
types[n] = random_generate(randomPtr) % NUM_RESERVATION_TYPE;
ids[n] = (random_generate(randomPtr) % queryRange) + 1;
}
bool_t isFound = FALSE;
TM_BEGIN();
for (n = 0; n < numQuery; n++) {
long t = types[n];
long id = ids[n];
long price = -1;
switch (t) {
case RESERVATION_CAR:
if (MANAGER_QUERY_CAR(managerPtr, id) >= 0) {
price = MANAGER_QUERY_CAR_PRICE(managerPtr, id);
}
break;
case RESERVATION_FLIGHT:
if (MANAGER_QUERY_FLIGHT(managerPtr, id) >= 0) {
price = MANAGER_QUERY_FLIGHT_PRICE(managerPtr, id);
}
break;
case RESERVATION_ROOM:
if (MANAGER_QUERY_ROOM(managerPtr, id) >= 0) {
price = MANAGER_QUERY_ROOM_PRICE(managerPtr, id);
}
break;
default:
assert(0);
}
if (price > maxPrices[t]) {
maxPrices[t] = price;
maxIds[t] = id;
isFound = TRUE;
}
} /* for n */
if (isFound) {
MANAGER_ADD_CUSTOMER(managerPtr, customerId);
}
if (maxIds[RESERVATION_CAR] > 0) {
MANAGER_RESERVE_CAR(managerPtr,
customerId, maxIds[RESERVATION_CAR]);
}
if (maxIds[RESERVATION_FLIGHT] > 0) {
MANAGER_RESERVE_FLIGHT(managerPtr,
customerId, maxIds[RESERVATION_FLIGHT]);
}
if (maxIds[RESERVATION_ROOM] > 0) {
MANAGER_RESERVE_ROOM(managerPtr,
customerId, maxIds[RESERVATION_ROOM]);
}
TM_END();
break;
}
case ACTION_DELETE_CUSTOMER: {
long customerId = random_generate(randomPtr) % queryRange + 1;
TM_BEGIN();
long bill = MANAGER_QUERY_CUSTOMER_BILL(managerPtr, customerId);
if (bill >= 0) {
MANAGER_DELETE_CUSTOMER(managerPtr, customerId);
}
TM_END();
break;
}
case ACTION_UPDATE_TABLES: {
long numUpdate = random_generate(randomPtr) % numQueryPerTransaction + 1;
long n;
for (n = 0; n < numUpdate; n++) {
types[n] = random_generate(randomPtr) % NUM_RESERVATION_TYPE;
ids[n] = (random_generate(randomPtr) % queryRange) + 1;
ops[n] = random_generate(randomPtr) % 2;
if (ops[n]) {
prices[n] = ((random_generate(randomPtr) % 5) * 10) + 50;
}
}
TM_BEGIN();
for (n = 0; n < numUpdate; n++) {
long t = types[n];
long id = ids[n];
long doAdd = ops[n];
if (doAdd) {
long newPrice = prices[n];
switch (t) {
case RESERVATION_CAR:
MANAGER_ADD_CAR(managerPtr, id, 100, newPrice);
break;
case RESERVATION_FLIGHT:
MANAGER_ADD_FLIGHT(managerPtr, id, 100, newPrice);
break;
case RESERVATION_ROOM:
MANAGER_ADD_ROOM(managerPtr, id, 100, newPrice);
break;
default:
assert(0);
}
} else { /* do delete */
switch (t) {
case RESERVATION_CAR:
MANAGER_DELETE_CAR(managerPtr, id, 100);
break;
case RESERVATION_FLIGHT:
MANAGER_DELETE_FLIGHT(managerPtr, id);
break;
case RESERVATION_ROOM:
MANAGER_DELETE_ROOM(managerPtr, id, 100);
break;
default:
assert(0);
}
}
}
TM_END();
break;
}
default:
assert(0);
} /* switch (action) */
} /* for i */
TM_THREAD_EXIT();
}
// returns if it was able to process
bool Player::process_note_and_instrument(int p_track,int p_note,int p_instrument) {
bool aux_result;
aux_result=false;
Sample *aux_sample=0; // current sample
int dest_sample_index;
bool new_instrument=false;
control.channel[p_track].row_has_note=false; // wise man says.. "we dont have a note... until we really know we have a note".
control.channel[p_track].new_instrument=false;
if ( (p_note<0) && (p_instrument<0) ) return aux_result; // nothing to do here
if ( (p_note==255) && (p_instrument==255) ) return aux_result;
if ( (p_note>=0) && (p_note<120) ) {
process_new_note(p_track,p_note);
} else if (p_note==Note::CUT) {
control.channel[p_track].aux_volume=0;
control.channel[p_track].note_end_flags|=END_NOTE_OFF;
control.channel[p_track].note_end_flags|=END_NOTE_KILL;
return aux_result;
} else if ((p_note==Note::OFF) && (song->has_instruments())) {
if (control.channel[p_track].instrument_ptr!=NULL) {
control.channel[p_track].note_end_flags|=END_NOTE_OFF;
if (!control.channel[p_track].instrument_ptr->get_volume_envelope()->is_enabled() || control.channel[p_track].instrument_ptr->get_volume_envelope()->is_loop_enabled()) {
control.channel[p_track].note_end_flags|=END_NOTE_FADE;
}
}
return aux_result;
} else return aux_result; // invalid note!
if ( (p_instrument>=0) && (p_instrument<Song::MAX_INSTRUMENTS)) {
new_instrument=process_new_instrument(p_track,p_instrument);
if ( song->has_instruments() ) {
// If we're in instrument mode...
if ( control.channel[p_track].instrument_ptr->get_sample_number(control.channel[p_track].real_note) >= Song::MAX_SAMPLES) {
control.channel[p_track].kick=KICK_NOTHING;
return aux_result;
} else {
dest_sample_index=control.channel[p_track].instrument_ptr->get_sample_number(control.channel[p_track].real_note);
control.channel[p_track].note=control.channel[p_track].instrument_ptr->get_note_number(control.channel[p_track].real_note);
}
} else {
// If we're in sample mode...
dest_sample_index=control.channel[p_track].instrument_index;
control.channel[p_track].note=control.channel[p_track].real_note;
}
control.channel[p_track].sample_index=dest_sample_index;
aux_sample=song->get_sample(dest_sample_index);
if (!SampleManager::get_singleton()->check( aux_sample->get_sample_data() )) {
/* INVALID SAMPLE */
control.channel[p_track].kick=KICK_NOTHING;
return aux_result;
}
aux_sample=song->get_sample(dest_sample_index);
} else {
if (!control.channel[p_track].sample_ptr)
return aux_result;
if (song->has_instruments()) {
if (!control.channel[p_track].instrument_ptr)
return aux_result;
control.channel[p_track].note=control.channel[p_track].instrument_ptr->get_note_number(control.channel[p_track].real_note);
} else {
control.channel[p_track].note=control.channel[p_track].real_note;
}
aux_sample=control.channel[p_track].sample_ptr;
}
if (p_instrument>=Song::MAX_INSTRUMENTS && control.channel[p_track].sample_ptr!=aux_sample) {
control.channel[p_track].new_instrument=(control.channel[p_track].period>0);
}
control.channel[p_track].sample_ptr=aux_sample;
/* channel or instrument determined panning ? */
control.channel[p_track].panning=control.channel[p_track].channel_panning;
/* set filter,if any ? */
if (aux_sample->is_pan_enabled()) {
control.channel[p_track].panning=(int)aux_sample->get_pan()*255/64;
} else if ( song->has_instruments() && (control.channel[p_track].instrument_ptr->is_pan_default_enabled()) ) {
control.channel[p_track].panning=(int)control.channel[p_track].instrument_ptr->get_pan_default_amount()*255/64;
}
if (song->has_instruments()) {
/* Pitch-Pan Separation */
if ((control.channel[p_track].instrument_ptr->get_pan_pitch_separation()!=0) && (control.channel[p_track].channel_panning!=PAN_SURROUND)){
control.channel[p_track].panning+=((control.channel[p_track].real_note-control.channel[p_track].instrument_ptr->get_pan_pitch_center())*control.channel[p_track].instrument_ptr->get_pan_pitch_separation())/8;
if (control.channel[p_track].panning<PAN_LEFT) control.channel[p_track].panning=PAN_LEFT;
if (control.channel[p_track].panning>PAN_RIGHT) control.channel[p_track].panning=PAN_RIGHT;
}
/* Random Volume Variation */
if (control.channel[p_track].instrument_ptr->get_volume_random_variation()>0) {
control.channel[p_track].random_volume_variation=100-(random_generate(&control.random_seed) % control.channel[p_track].instrument_ptr->get_volume_random_variation());
} else {
control.channel[p_track].random_volume_variation=100;
}
/* Random Pan Variation */
if ((control.channel[p_track].instrument_ptr->get_pan_random_variation()>0) && (control.channel[p_track].panning!=PAN_SURROUND)){
int aux_pan_modifier;
aux_pan_modifier=(random_generate(&control.random_seed) % (control.channel[p_track].instrument_ptr->get_pan_random_variation() << 2));
if ((random_generate(&control.random_seed) % 2)==1) aux_pan_modifier=0-aux_pan_modifier; /* it's 5am, let me sleep :) */
control.channel[p_track].panning+=aux_pan_modifier;
if (control.channel[p_track].panning<PAN_LEFT) control.channel[p_track].panning=PAN_LEFT;
if (control.channel[p_track].panning>PAN_RIGHT) control.channel[p_track].panning=PAN_RIGHT;
}
/*filter*/
if (control.channel[p_track].instrument_ptr->filter_use_default_cutoff()) {
control.channel[p_track].filter.it_cutoff=control.channel[p_track].instrument_ptr->get_filter_default_cutoff()*2;
}
if (control.channel[p_track].instrument_ptr->filter_use_default_resonance()) {
control.channel[p_track].filter.it_reso=control.channel[p_track].instrument_ptr->get_filter_default_resonance()*2;
}
/*envelopes*/
control.channel[p_track].volume_envelope_on=control.channel[p_track].instrument_ptr->get_volume_envelope()->is_enabled();
control.channel[p_track].panning_envelope_on=control.channel[p_track].instrument_ptr->get_pan_envelope()->is_enabled();
control.channel[p_track].pitch_envelope_on=control.channel[p_track].instrument_ptr->get_pitch_filter_envelope()->is_enabled();
control.channel[p_track].NNA_type=control.channel[p_track].instrument_ptr->get_NNA_type();
control.channel[p_track].duplicate_check_type=control.channel[p_track].instrument_ptr->get_DC_type();
control.channel[p_track].duplicate_check_action=control.channel[p_track].instrument_ptr->get_DC_action();
} else {
control.channel[p_track].NNA_type=Instrument::NNA_NOTE_CUT;
control.channel[p_track].duplicate_check_type=Instrument::DCT_DISABLED;
control.channel[p_track].duplicate_check_action=Instrument::DCA_NOTE_CUT;
}
if (p_instrument<Song::MAX_INSTRUMENTS) { // instrument change
control.channel[p_track].volume=control.channel[p_track].aux_volume=aux_sample->get_default_volume();
}
control.channel[p_track].slide_to_period=control.channel[p_track].aux_period=get_period((Uint16)(control.channel[p_track].note)<<1,SampleManager::get_singleton()->get_c5_freq( (aux_sample->get_sample_data())));
control.channel[p_track].note_end_flags=END_NOTE_NOTHING; /* clears flags */
return true;
}