Exemple #1
0
        internal PadIntCommitted CreatePadInt(ulong tid, int uid, bool isReplicating)
        {
            Console.WriteLine("Create padInt " + uid);

            if (objectsInServer.ContainsKey(uid))
            {
                return(null);
            }


            PadIntTransaction obj = new PadIntTransaction(uid);

            PadIntCommitted committed = new PadIntCommitted(uid);

            obj.setCommited(committed);

            objectsInServer[uid] = obj;

            //wait handle não notificado e com manual reset pois deve ser o write a fechar a passagem às threads.
            objectWaitHandle[uid]    = new EventWaitHandle(false, EventResetMode.ManualReset);//esta errado? se for criado, todas as threads devem puder passar por handle certo?
            pendingTransactions[uid] = new EventWaitHandle(false, EventResetMode.ManualReset);



            if (!isReplicating)
            {
                Write(tid, uid, 0);
            }


            return(committed);
        }
Exemple #2
0
        //o doCommit deveria ser atomico. pode dar problema?
        internal bool doCommit(ulong tid)
        {
            PadIntTransaction objectTransaction = null;
            PadIntTentative   tentative         = null;
            PadIntCommitted   commited          = null;

            List <PadIntRemote> toReplicate = new List <PadIntRemote>();

            //desbloquear threads em espera no read com
            Console.WriteLine("Em do commit Tid: " + tid);

            foreach (int modifiedObject in transactions[tid].getModifiedObjectIds())
            {
                //Console.WriteLine("Em do commit no for Tid: " + tid + "modificou" + modifiedObject);

                //por commited
                //remover objecto transaccao
                //remover objecto tentativa
                //por tentativa como commited se vamos remover vale a pena? ter em atenção que no read ele ve se o anterior esta commited. nao sei se deviamos eliminar.
                //actualizar o valor do commited


                objectTransaction = objectsInServer[modifiedObject];

                SortedList <ulong, PadIntTentative> tentatives = objectTransaction.getTentatives();
                tentative = tentatives[tid];

                commited = objectTransaction.getCommitted();
                commited.WriteTimestamp = tid;
                commited.Value          = tentative.Value;

                toReplicate.Add(commited);

                tentative.SetCommited();
                tentatives.Remove(tid);

                objectWaitHandle[modifiedObject].Set();//fez commit.temos de notificar threads para avancarem.
                pendingTransactions[modifiedObject].Set();
            }

            transactions[tid].setCommited();
            //Transacção efectuda e agora removida
            transactions.Remove(tid);

            if (replica != null)
            {
                replica.SendPadInt(toReplicate);
            }

            foreach (var p in toReplicate)
            {
                Console.WriteLine("replicado = " + p.uid + " " + p.Value);
            }

            checkTableOfPendingTransactions(tid);

            return(true); //sempre verdade?
        }
Exemple #3
0
        internal bool doAbort(ulong tid)
        {
            Console.WriteLine("doAbort");

            PadIntTransaction objectTransaction = null;
            PadIntTentative   tentative         = null;

            //desbloquear threads em espera no read com
            foreach (int modifiedObject in transactions[tid].getModifiedObjectIds())
            {
                Console.WriteLine("Abort: " + modifiedObject);
                //por abort
                //remover objecto transaccao check
                //remover objecto tentativa check
                //por tentativa como commited se vamos remover vale a pena? ter em atenção que no read ele ve se o anterior esta commited. nao sei se deviamos eliminar.
                //actualizar o valor do commited


                objectTransaction = objectsInServer[modifiedObject];



                SortedList <ulong, PadIntTentative> tentatives = objectTransaction.getTentatives();

                tentative = tentatives[tid];
                tentative.SetAborted();

                tentatives.Remove(tid);

                PadIntCommitted com = objectTransaction.getCommitted();

                //Remove creates
                if (com.WriteTimestamp == 0)
                {
                    objectsInServer.Remove(modifiedObject);

                    objectWaitHandle[modifiedObject].Set();//fez commit.temos de notificar threads para avancarem.
                    pendingTransactions[modifiedObject].Set();

                    objectWaitHandle.Remove(modifiedObject);//fez commit.temos de notificar threads para avancarem.
                    pendingTransactions.Remove(modifiedObject);
                }
                else
                {
                    objectWaitHandle[modifiedObject].Set();//fez commit.temos de notificar threads para avancarem.
                    pendingTransactions[modifiedObject].Set();
                }
            }

            transactions[tid].setAborted();
            //Transacção efectuda e agora removida
            transactions.Remove(tid);

            return(true); //sempre verdade?
        }
Exemple #4
0
        public void AddPadInts(List <PadIntRemote> padInts)
        {
            Console.WriteLine("recebeu dados");
            foreach (PadIntCommitted pad in padInts)
            {
                Console.WriteLine("recebeu padint " + pad.uid);
                Console.WriteLine("recebeu padint " + pad.Value);

                PadIntCommitted p = CreatePadInt(pad.WriteTimestamp, pad.uid, true);


                //Ainda na existe no server
                if (p != null)
                {
                    p.WriteTimestamp = pad.WriteTimestamp;
                    p.Value          = pad.Value;
                }
                else
                {
                    //ja existe no server
                    objectsInServer[pad.uid].getCommitted().WriteTimestamp = pad.WriteTimestamp;
                    objectsInServer[pad.uid].getCommitted().Value          = pad.Value;
                }

                //PadIntTransaction padTransaction = new PadIntTransaction(pad.uid);
                //padTransaction.setCommited(pad);

                //if (!objectsInServer.ContainsKey(pad.uid)){
                //    objectsInServer.Add(pad.uid, padTransaction);
                //}
                //else
                //{
                //    objectsInServer[pad.uid] = padTransaction;
                //}

                //objectWaitHandle[uid] = new EventWaitHandle(false, EventResetMode.ManualReset);//esta errado? se for criado, todas as threads devem puder passar por handle certo?
                //pendingTransactions[uid] = new EventWaitHandle(false, EventResetMode.ManualReset);
            }

            //transferencia concluida
            Console.WriteLine("transferencia concluida");
            waitForPadIntTransfer.Set();
        }
Exemple #5
0
 public void setCommited(PadIntCommitted committed)
 {
     this.committed = committed;
 }
        internal PadIntCommitted CreatePadInt(ulong tid, int uid, bool isReplicating)
        {
            Console.WriteLine("Create padInt " + uid);

            if (objectsInServer.ContainsKey(uid))
                return null;

            PadIntTransaction obj = new PadIntTransaction(uid);

            PadIntCommitted committed = new PadIntCommitted(uid);
            obj.setCommited(committed);

            objectsInServer[uid] = obj;

            //wait handle não notificado e com manual reset pois deve ser o write a fechar a passagem às threads.
            objectWaitHandle[uid] = new EventWaitHandle(false, EventResetMode.ManualReset);//esta errado? se for criado, todas as threads devem puder passar por handle certo?
            pendingTransactions[uid] = new EventWaitHandle(false, EventResetMode.ManualReset);

            if (!isReplicating)
                Write(tid, uid, 0);

            return committed;
        }
 public void setCommited(PadIntCommitted committed)
 {
     this.committed = committed;
 }
Exemple #8
0
        internal void Write(ulong tid, int uid, int value)
        {
            //addicionar objecto modificado

            //ServerApp.debug = "Write called!";

            //fica a espera que sejam transferidos dados de um servidor que sofreu divisao do seeu range pela entrada deste novo server
            if (tid > maxTID)
            {
                waitForPadIntTransfer.Reset();
            }

            if (!objectsInServer.ContainsKey(uid))
            {
                //O objecto nao foi criado no servidor
                throw new PadIntNotExists(tid, uid);
            }

            PadIntTransaction obj       = objectsInServer[uid];
            PadIntCommitted   committed = obj.getCommitted();
            ulong             tc        = committed.WriteTimestamp;

            //Verificacao 1: Ja existem escritas committed com timestamp superior ao desta transaccao
            if (tid <= tc)
            {
                throw new PadIntWriteTooLate(tid, uid);
            }
            //Debug.WriteLine();

            SortedList <ulong, PadIntTentative> tentatives = obj.getTentatives();

            PadIntTentative t;

            //Não existem transações a mexer no objecto com identificador uid
            if (tentatives.Count == 0)
            {
                t = new PadIntTentative(uid, tid, value);

                obj.addTentative(tid, t);

                transactions[tid].addModifiedObjectId(uid); ////depois de modificar o object, adiciona-lo à transaccao para sabermos o que mudamos no fim.

                objectWaitHandle[uid].Reset();              //escreveu, bloqueia as threads. O que acontece se não fôr a tempo de bloquear as threads???????
                pendingTransactions[uid].Reset();           // dado que escrevemos, as que forem fazer commit teem de esperar

                //evitar que venha a esperar por si mesma espera por si mesma?
                return;
            }

            //Max de timestamp de leitura das versoes

            //Func<PadIntTentative, decimal> lam = tent => (decimal) tent.ReadTimestamp;

            // ulong tMax = tentatives.Max<PadIntTentative,ulong>(x => x.ReadTimestamp); //metodos extendidos. porque nao da? Não apagar. Ainda tenho de
            //perceber isto Ass:Braga :)

            ulong tMax = (ulong)tentatives.Max(x => x.Value.ReadTimestamp);

            //Console.WriteLine("Tid: " + tid + "Tmax: " + tMax);

            //Verificacao 2: Ja existem leituras de transaccoes a serem processadas
            if (tid < tMax)
            {
                throw new PadIntWriteTooLate(tid, uid);
            }


            if (tentatives.ContainsKey(tid))
            {
                PadIntTentative transactionTentative = tentatives[tid];
                // transactionTentative.Write(value);--> ja existe uma property
                //se tem tentativa é porque já escreveu antes. Não é preciso resetar o handle? Ou é????????
                transactionTentative.Value = value;
            }

            else//primeira tentativa da transacçao tid
            {
                t = new PadIntTentative(uid, tid, value);
                obj.addTentative(tid, t);

                transactions[tid].addModifiedObjectId(uid); ////depois de modificar o object, adiciona-lo à transaccao para sabermos o que mudamos no fim.
                objectWaitHandle[uid].Reset();              ///primeira tentativa de escrita. Reseta handle para bloquear threads.
                pendingTransactions[uid].Reset();           // dado que escrevemos, as que forem fazer commit teem de esperar
            }
        }
Exemple #9
0
        internal int Read(ulong tid, int uid)
        {
            //ServerApp.debug = "Read called!";

            //fica a espera que sejam transferidos dados de um servidor que sofreu divisao do seeu range pela entrada deste novo server
            if (tid > maxTID)
            {
                //Console.WriteLine("read: tid>mazxTID");

                waitForPadIntTransfer.Reset();
            }


            if (!objectsInServer.ContainsKey(uid))
            {
                //O objecto nao foi criado no servidor
                throw new PadIntNotExists(tid, uid);
            }

            PadIntTransaction obj       = objectsInServer[uid];
            PadIntCommitted   committed = obj.getCommitted();
            // return committed.Read();

            ulong tc = committed.WriteTimestamp;

            //ServerApp.debug = "Object commited with value: " + committed.Value;

            //Console.WriteLine(String.Format("on read:Tid:{0} Tc:{1}", tid, tc));
            if (tid <= tc)
            {
                throw new PadIntReadTooLate(tid, uid);
            }

            SortedList <ulong, PadIntTentative> tentatives = obj.getTentatives();

            //se não existirem versões tentativa, ele não/ninguém escreveu. pode ler do commited.
            if (tentatives.Count == 0)
            {
                objectsInServer[uid].addTentative(tid, new PadIntTentative(uid, tid, tid, committed.Value)); //////////////////////////////////////////////////////////////////////

                transactions[tid].addModifiedObjectId(uid);                                                  ////depois de modificar o object, adiciona-lo à transaccao para sabermos o que mudamos no fim.

                pendingTransactions[uid].Reset();                                                            // dado que temos uma tentativa, as que forem fazer commit teem de esperar

                return(committed.Value);
            }


            //se ja foi escrita uma versao, entao le-se dessa versão.
            if (tentatives.ContainsKey(tid))
            {
                PadIntTentative ownTentative = tentatives[tid];
                ownTentative.ReadTimestamp = tid;
                return(ownTentative.Value);
            }

            //versao de tentativa que tem um timestamp de escrita superior a todos os inferiores ao da transaccao que quer ler.
            PadIntTentative mostUpdated = tentatives.Values.Where(x => ((x.WriteTimestamp < tid) ? true : false)).Max(x => x.WriteTimestamp < tid ? x : null);

            //se nao existe nenhum que tenha escrito e que tenha timestamp inferior, significa que a transaccao actual pode ler o valor do commited.
            if (mostUpdated == null)
            {
                objectsInServer[uid].addTentative(tid, new PadIntTentative(uid, tid, tid, committed.Value)); //////////////////////////////////////////////////////////////////////

                transactions[tid].addModifiedObjectId(uid);                                                  ////depois de modificar o object, adiciona-lo à transaccao para sabermos o que mudamos no fim.

                pendingTransactions[uid].Reset();                                                            // dado que temos uma tentativa, as que forem fazer commit teem de esperar
                return(committed.Value);
            }


            ulong tMax = mostUpdated.WriteTimestamp;// este e o valor do maior timestamp de escrita menor que o da transaccao

            //verificar se a versao commited tem um timestamp igual ao de tmax. se tiver, significa que o tmax está commited. pode então ler
            if (tc == tMax)//pode ler
            {
                mostUpdated.ReadTimestamp = tid;
                return(mostUpdated.Value);
            }
            else //espera que a transaccao faca commit e volta a repetir todos os passos até aqui.É criada uma thred para cada chamada a esta função.
            {
                objectWaitHandle[uid].WaitOne(); //bloqueia e quando fôr desbloqueada, volta a tentar.

                return(Read(tid, uid));
            }
        }