Пример #1
0
        public AuditLog_other(StorageTypes storageType, string dbConnStr)
        {
            m_storageType = storageType;
            m_dbConnStr   = dbConnStr;

            m_storageLayer = new StorageLayer(m_storageType, m_dbConnStr);
        }
Пример #2
0
        public void GlobalSetup()
        {
            if (Directory.Exists(_outputFolder))
            {
                Directory.Delete(_outputFolder, true);
            }
            Directory.CreateDirectory(_outputFolder);

            var dbFolder  = "D:\\stress";
            var dbOptions = new TrimDatabaseOptions();


            _cache = dbOptions.BlockCache();
            var filenames = Directory.GetFiles(dbFolder);

            _tableFiles = new TableFile[filenames.Length];

            _storageLayer = new SortedStorageLayer(5, _outputFolder, _cache, 10 * 1024 * 1024, 100);

            for (var i = 0; i < _tableFiles.Length; i++)
            {
                var tf = new TableFile(filenames[i], _cache);
                tf.LoadAsync().Wait();
                _tableFiles[i] = tf;
            }
        }
Пример #3
0
		public AuditLog_other(StorageTypes storageType, string dbConnStr)
		{
			m_storageType = storageType;
			m_dbConnStr = dbConnStr;

			m_storageLayer = new StorageLayer(m_storageType, m_dbConnStr);
		}
        public void Handle(StorageLayer layer, Action<FlowProcessingResponse> put)
        {
            HandlerHelper.SendStartMessage(
                "Generating...",
                FlowProcessingRequestType.GenerateRuntimeBitmap,
                layer,
                put);

            var runtime = this.m_AlgorithmFlowImageGeneration.RegenerateImageForLayer(
                layer,
                this.m_CurrentWorldSeedProvider.Seed,
                this.m_RenderingLocationProvider.X,
                this.m_RenderingLocationProvider.Y,
                this.m_RenderingLocationProvider.Z,
                64,
                64,
                64);

            put(new FlowProcessingResponse
            {
                RequestType = FlowProcessingRequestType.GenerateRuntimeBitmap,
                IsStartNotification = false,
                Results = new object[] { layer, runtime }
            });
        }
Пример #5
0
 public AnalysisLayer(StorageLayer layer)
 {
     AstBuilder astBuilder;
     var method = DecompileUtil.GetMethodCode(layer.Algorithm.GetType(), out astBuilder, "ProcessCell");
     this.Name = layer.Algorithm.GetType().Name;
     this.Code = method.Body.GetTrackedText();
     this.Algorithm = layer.Algorithm;
     this.AstBuilder = astBuilder;
 }
        public static Bitmap RegenerateImageForLayer(StorageLayer layer, long ox, long oy, long oz, int width, int height, int depth, bool compiled = false)
        {
            var runtime = StorageAccess.ToRuntime(layer);

            //if (compiled)
            //    return Regenerate3DImageForLayer(runtime, ox, oy, oz, width, height, depth, StorageAccess.ToCompiled(layer));
            //else
            return(Regenerate3DImageForLayer(runtime, ox, oy, oz, width, height, depth));
        }
Пример #7
0
        public AnalysisLayer(StorageLayer layer)
        {
            AstBuilder astBuilder;
            var        method = DecompileUtil.GetAlgorithmCode(layer.Algorithm.GetType(), out astBuilder);

            this.Name       = layer.Algorithm.GetType().Name;
            this.Code       = method.Body.GetTrackedText();
            this.Algorithm  = layer.Algorithm;
            this.AstBuilder = astBuilder;
        }
        public Bitmap RegenerateImageForLayer(
            StorageLayer layer,
            long seed,
            long ox, 
            long oy, 
            long oz,
            int width, 
            int height, 
            int depth,
            bool compiled = false)
        {
            try
            {
                var runtime = this.m_StorageAccess.ToRuntime(layer);
                runtime.SetSeed(seed);
                if (compiled)
                {
                    try
                    {
                        return this.m_IsometricBitmapRenderer.GenerateImage(
                            runtime,
                            x => runtime.Algorithm.GetColorForValue(this.m_StorageAccess.FromRuntime(runtime), x),
                            ox,
                            oy,
                            oz,
                            width,
                            height,
                            runtime.Algorithm.Is2DOnly ? 1 : depth);
                        /*return Regenerate3DImageForLayer(
                            runtime,
                            ox, oy, oz,
                            width, height, depth,
                            this.m_StorageAccess.ToCompiled(runtime));*/
                    }
                    catch (Exception)
                    {
                        return null;
                    }
                }

                return this.m_IsometricBitmapRenderer.GenerateImage(
                    runtime,
                    x => runtime.Algorithm.GetColorForValue(this.m_StorageAccess.FromRuntime(runtime), x),
                    ox,
                    oy,
                    oz,
                    width,
                    height,
                    runtime.Algorithm.Is2DOnly ? 1 : depth);
            }
            catch (InvalidOperationException)
            {
                return null;
            }
        }
Пример #9
0
        private int[] ParentsIndexOf(StorageLayer find)
        {
            List <int> result = new List <int>();

            for (int i = 0; i < this.m_Layer.Inputs.Length; i++)
            {
                if (this.m_Layer.Inputs[i] == find)
                {
                    result.Add(i);
                }
            }
            return(result.ToArray());
        }
Пример #10
0
        public AlgorithmFlowElement(FlowInterfaceControl control, StorageLayer l)
        {
            this.m_Control = control;
            this.m_Layer   = l;
            var attrs = l.Algorithm.GetType().GetCustomAttributes(typeof(FlowDesignerNameAttribute), true);

            this.Name        = attrs.Length > 0 ? (attrs[0] as FlowDesignerNameAttribute).Name : l.Algorithm.ToString();
            this.ImageWidth  = 128;
            this.ImageHeight = 192;
            this.ObjectPropertyUpdated();

            // Create input / output connectors.
            foreach (string s in this.m_Layer.Algorithm.InputNames)
            {
                this.m_InputConnectors.Add(new AlgorithmFlowConnector(this, s, true, l));
            }
            this.m_OutputConnectors.Add(new AlgorithmFlowConnector(this, "Output", false, l));

            this.m_CompiledViewToggleThread = new Thread(() =>
            {
                while (this.m_CompiledViewToggleThread.ThreadState != ThreadState.AbortRequested)
                {
                    Thread.Sleep(100);
                    if (this.m_RealBitmap == this.m_RuntimeBitmap)
                    {
                        this.m_RealBitmap = this.m_CompiledBitmap;
                    }
                    else
                    {
                        this.m_RealBitmap = this.m_RuntimeBitmap;
                    }
                    try
                    {
                        this.m_Control.Invoke(new Action(() =>
                        {
                            this.m_Control.Invalidate(this.InvalidatingRegion.Apply(this.m_Control.Zoom));
                        }));
                    }
                    catch
                    {
                        break;
                    }
                }
            });
            this.m_CompiledViewToggleThread.Start();
        }
Пример #11
0
        public AlgorithmFlowElement(
            FlowInterfaceControl control, 
            IFlowProcessingPipeline processingPipeline,
            StorageLayer l)
        {
            this.m_Control = control;
            this.m_FlowProcessingPipeline = processingPipeline;
            this.m_Layer = l;
            var attrs = l.Algorithm.GetType().GetCustomAttributes(typeof(FlowDesignerNameAttribute), true);
            this.Name = attrs.Length > 0 ? (attrs[0] as FlowDesignerNameAttribute).Name : l.Algorithm.ToString();
            this.ImageWidth = 128;
            this.ImageHeight = 192;
            this.ObjectPropertyUpdated();

            // Create input / output connectors.
            foreach (string s in this.m_Layer.Algorithm.InputNames)
                this.m_InputConnectors.Add(new AlgorithmFlowConnector(this, s, true, l));
            this.m_OutputConnectors.Add(new AlgorithmFlowConnector(this, "Output", false, l));

            /*this.m_CompiledViewToggleThread = new Thread(() =>
            {
                while (this.m_CompiledViewToggleThread.ThreadState != ThreadState.AbortRequested)
                {
                    Thread.Sleep(100);
                    if (this.m_RealBitmap == this.m_RuntimeBitmap)
                        this.m_RealBitmap = this.m_CompiledBitmap;
                    else
                        this.m_RealBitmap = this.m_RuntimeBitmap;
                    try
                    {
                        this.m_Control.Invoke(new Action(() =>
                        {
                            this.m_Control.Invalidate(this.InvalidatingRegion.Apply(this.m_Control.Zoom));
                        }));
                    }
                    catch
                    {
                        break;
                    }
                }
            });
            this.m_CompiledViewToggleThread.Start();*/
        }
Пример #12
0
        public static void SendStartMessage(
            string message,
            FlowProcessingRequestType type,
            StorageLayer layer,
            Action<FlowProcessingResponse> put)
        {
            var info = new Bitmap(
                128,
                message.Split(new[] { "\r\n" }, StringSplitOptions.None).Length * 16);
            var graphics = Graphics.FromImage(info);
            var font = new Font(SystemFonts.DefaultFont, FontStyle.Bold);
            var brush = new SolidBrush(Color.White);
            graphics.Clear(Color.Black);
            graphics.DrawString(message, font, brush, new PointF(0, 0));

            put(new FlowProcessingResponse
            {
                RequestType = type,
                IsStartNotification = true,
                Results = new object[] { layer, info }
            });
        }
Пример #13
0
        private void RestoreNotFinishedTransactions()
        {
            //TODO Trie settings from the table must be taken from schema (when they will differ)

            //STORE FILE NAME of rollback not table name
            try
            {
                byte[]        btCommittedTablesNames = null;
                List <string> committedTablesNames   = new List <string>();

                if (LTrie.Count(false) == 0)     //All ok
                {
                    LTrie.RemoveAll(true);
                    return;
                }

                string physicalPathToTheUserTable = String.Empty;

                //Settigns and storage for Committed tables !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!   MUST BE TAKEN FROM SCHEMA, FOR NOW DEFAULT
                TrieSettings            ltrSet  = null;
                IStorage                storage = null;
                DBriize.LianaTrie.LTrie ltrie   = null;


                foreach (var row in LTrie.IterateForward(true, false))
                {
                    btCommittedTablesNames = row.GetFullValue(true);

                    committedTablesNames = System.Text.Encoding.UTF8.GetString(btCommittedTablesNames).DeserializeXml <List <string> >();

                    foreach (var fn in committedTablesNames)
                    {
                        //Trying to get path from the Schema, there is universal function for getting table physical TABLE FULL PATH /NAME

                        physicalPathToTheUserTable = Engine.DBriizeSchema.GetPhysicalPathToTheUserTable(fn);

                        //Returned path can be empty, if no more such table
                        if (physicalPathToTheUserTable == String.Empty)
                        {
                            continue;
                        }

                        //We don't restore in-memory tables
                        if (physicalPathToTheUserTable == "MEMORY")
                        {
                            continue;
                        }

                        //we open ltrie, and it automatically restores rollback
                        ltrSet = new TrieSettings();     //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!   MUST BE TAKEN FROM SCHEMA, FOR NOW DEFAULT
                        //storage = new TrieDiskStorage(physicalPathToTheUserTable, ltrSet, Engine.Configuration);
                        storage = new StorageLayer(physicalPathToTheUserTable, ltrSet, Engine.Configuration);
                        ltrie   = new LTrie(storage);

                        //closing trie, that Schema could open it again
                        ltrie.Dispose();

                        ////Deleting rollback file for such table
                        //physicalPathToTheUserTable += ".rol";
                        //System.IO.File.Delete(physicalPathToTheUserTable);
                    }

                    committedTablesNames.Clear();
                }

                //If all ok, recreate file
                LTrie.RemoveAll(true);
            }
            catch (OperationCanceledException ex)
            {
                throw ex;
            }
            //catch (System.Threading.ThreadAbortException ex)
            //{
            //    //We don'T make DBisOperable = false;
            //    throw ex;
            //}
            catch (Exception)
            {
                //BRINGS TO DB NOT OPERATABLE
                this.Engine.DBisOperable       = false;
                this.Engine.DBisOperableReason = "TransactionsCoordinator.RestoreNotFinishedTransaction";
                //NOT CASCADE ADD EXCEPTION
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.CLEAN_ROLLBACK_FILES_FOR_FINISHED_TRANSACTIONS_FAILED);
            }
        }
Пример #14
0
 private int[] ParentsIndexOf(StorageLayer find)
 {
     var result = new List<int>();
     for (var i = 0; i < this.m_Layer.Inputs.Length; i++)
         if (this.m_Layer.Inputs[i] == find)
             result.Add(i);
     return result.ToArray();
 }
Пример #15
0
 public HealthController(StorageLayer storageLayer)
 {
     _storageLayer = storageLayer;
 }
        public void Handle(StorageLayer layer, Action<FlowProcessingResponse> put)
        {
            HandlerHelper.SendStartMessage(
                "Performance\r\ntesting...",
                FlowProcessingRequestType.GenerateRuntimeBitmap,
                layer,
                put);

            // Settings.
            var testTime = 50;
            var warningLimit = 5000; // 5ms
            var badLimit = 16000; // 16ms

            // Perform conversions.
            var runtime = this.m_StorageAccess.ToRuntime(layer);
            runtime.SetSeed(this.m_CurrentWorldSeedProvider.Seed);
            IGenerator compiled = null;
            try
            {
                compiled = this.m_StorageAccess.ToCompiled(runtime);
            }
            catch (Exception)
            {
                // Failed to compile layer.
            }

            // First check how many iterations of 8x8x8 generation the runtime layer can do in the test time.
            var runtimeStart = DateTime.Now;
            var runtimeComputations = 0;
            var iterations = 0;
            while ((DateTime.Now - runtimeStart).TotalMilliseconds < testTime)
            {
                runtime.GenerateData(0, 0, 0, 32, 32, 32, out runtimeComputations);
                iterations++;
            }

            var runtimeEnd = DateTime.Now;

            // Now check how long it takes the compiled layer to do as many iterations of generating 8x8x8.
            var compiledStart = DateTime.Now;
            var compiledComputations = 0;
            if (compiled != null)
            {
                try
                {
                    for (var i = 0; i < iterations; i++)
                        compiled.GenerateData(0, 0, 0, 32, 32, 32, out compiledComputations);
                }
                catch
                {
                    compiled = null;
                }
            }

            var compiledEnd = DateTime.Now;

            // Determine the per-operation cost.
            var runtimeCost = runtimeEnd - runtimeStart;
            var compiledCost = compiledEnd - compiledStart;
            var runtimeus = Math.Round((runtimeCost.TotalMilliseconds / iterations) * 1000, 0); // Microseconds.
            var compiledus = Math.Round((compiledCost.TotalMilliseconds / iterations) * 1000, 0);

            // Define colors and determine values.
            var okay = new SolidBrush(Color.LightGreen);
            var warning = new SolidBrush(Color.Orange);
            var bad = new SolidBrush(Color.IndianRed);
            var runtimeColor = okay;
            var compiledColor = okay;
            if (runtimeus > warningLimit)
                runtimeColor = warning;
            if (compiledus > warningLimit)
                compiledColor = warning;
            if (runtimeus > badLimit)
                runtimeColor = bad;
            if (compiledus > badLimit)
                compiledColor = bad;

            // Draw performance measurements.
            Bitmap bitmap;
            if (runtimeComputations != compiledComputations && compiled != null)
                bitmap = new Bitmap(128, 48);
            else
                bitmap = new Bitmap(128, 32);
            var graphics = Graphics.FromImage(bitmap);
            var font = new Font(SystemFonts.DefaultFont, FontStyle.Bold);
            graphics.Clear(Color.Black);
            if (runtimeComputations != compiledComputations && compiled != null)
            {
                graphics.DrawString("Computation mismatch!", font, bad, new PointF(0, 0));
                graphics.DrawString("Runtime:", font, runtimeColor, new PointF(0, 16));
                graphics.DrawString(runtimeComputations + "c", font, runtimeColor, new PointF(70, 16));
                if (compiled != null)
                {
                    graphics.DrawString("Compiled:", font, compiledColor, new PointF(0, 32));
                    graphics.DrawString(compiledComputations + "c", font, compiledColor, new PointF(70, 32));
                }
                else
                    graphics.DrawString("Unable to compile.", font, bad, new PointF(0, 32));
            }
            else
            {
                graphics.DrawString("Runtime:", font, runtimeColor, new PointF(0, 0));
                graphics.DrawString(runtimeus + "\xB5s", font, runtimeColor, new PointF(70, 0));
                if (compiled != null)
                {
                    graphics.DrawString("Compiled:", font, compiledColor, new PointF(0, 16));
                    graphics.DrawString(compiledus + "\xB5s", font, compiledColor, new PointF(70, 16));
                }
                else
                    graphics.DrawString("Unable to compile.", font, bad, new PointF(0, 16));
            }

            var additionalInformation = bitmap;
            Bitmap compiledBitmap = null;

            // Use the compiled layer to re-render the output.
            if (compiled != null)
            {
                compiledBitmap = this.m_AlgorithmFlowImageGeneration.RegenerateImageForLayer(
                    layer,
                    this.m_CurrentWorldSeedProvider.Seed,
                    this.m_RenderingLocationProvider.X,
                    this.m_RenderingLocationProvider.Y,
                    this.m_RenderingLocationProvider.Z,
                    64,
                    64,
                    64,
                    true);
            }

            put(new FlowProcessingResponse
            {
                RequestType = FlowProcessingRequestType.GeneratePerformanceResults,
                IsStartNotification = false,
                Results = new object[] { layer, additionalInformation, compiledBitmap }
            });
        }
Пример #17
0
 public AlgorithmFlowConnector(AlgorithmFlowElement owner, string name, bool isInput, StorageLayer layer)
     : base(owner, name, isInput)
 {
     this.m_LayerOwner = owner;
 }
Пример #18
0
        /// <summary>
        /// Returns table for READ, WRITE FUNC
        /// </summary>
        /// <param name="userTableName"></param>
        /// <returns></returns>
        internal LTrie GetTable(string userTableName)
        {
            string tableName = GetUserTableNameAsString(userTableName);

            //TODO pattern based mapping If table doesn't exist we create it with properties which could be supplied after db init as regex theme.



            //Schema protocol: 2 bytes - protocol version, other data
            //For protocol 1: first 8 bytes will be TheFileName, starting from db10000-dbN (0-N ulong). up to 10000 are reserved for dbreeze.

            //Table names are UTF-8 based, no limits

            ulong     fileName = 0;
            OpenTable otl      = null;

            _sync_openTablesHolder.EnterUpgradeableReadLock();
            try
            {
                _openTablesHolder.TryGetValue(tableName, out otl);

                if (otl != null)
                {
                    //Try to increase usage and return LTrie
                    otl.Add();
                    return(otl.Trie);
                }


                //Probably table Exists in db but not in openTablesHolder

                _sync_openTablesHolder.EnterWriteLock();
                try
                {
                    //UpgradeableRead recheck
                    _openTablesHolder.TryGetValue(tableName, out otl);

                    if (otl != null)
                    {
                        //Try to increase usage and return LTrie
                        otl.Add();
                        return(otl.Trie);
                    }



                    byte[] btTableName = GetUserTableNameAsByte(userTableName);

                    //Trying to get fileName from cache
                    fileName = this.cachedTableNames.GetFileName(tableName);
                    // LTrieRow row = null;
                    bool tableExists = false;

                    if (fileName == 0)
                    {
                        LTrieRow row = LTrie.GetKey(btTableName, false, false);


                        if (row.Exists)
                        {
                            tableExists = true;

                            byte[] fullValue = row.GetFullValue(false);
                            //Can be parsed different. First protocol version is 1
                            ushort schemeProtocol = fullValue.Substring(0, 2).To_UInt16_BigEndian();

                            switch (schemeProtocol)
                            {
                            case 1:
                                fileName = fullValue.Substring(2, 8).To_UInt64_BigEndian();
                                break;

                            default:
                                throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.SCHEME_FILE_PROTOCOL_IS_UNKNOWN);
                            }
                        }
                        else
                        {
                            tableExists = false;
                            //Creating new table.

                            //Checking table name validity

                            //this will throw exception, if not valid
                            DbUserTables.UserTableNameIsOk(userTableName);


                            //Creating such table and renewing LastFileNumber counter

                            //Adding to LastFileNumber
                            LastFileNumber++;


                            ////Deleting physical files related to the table, if they existed - normally they should not
                            //DeleteAllReleatedTableFiles(Path.Combine(Engine.MainFolder, LastFileNumber.ToString()));

                            byte[] lft = LastFileNumber.To_8_bytes_array_BigEndian();

                            //Writing this number to Schema file
                            LTrie.Add(Encoding.UTF8.GetBytes(LastFileNumberKeyName), lft);

                            //Creating table self and writing to Schema file

                            LTrie.Add(btTableName,
                                      new byte[] { 0, 1 } //Protocol version 1
                                      .Concat(lft));    //Number of the file

                            //Committing both records
                            LTrie.Commit();

                            fileName = LastFileNumber;

                            this.cachedTableNames.Add(tableName, fileName);
                        }
                    }
                    else
                    {
                        tableExists = true;
                    }

                    //Creating LTrie, adding it to _openTablesHolder

                    //Seeting up Trie TableName, OTHER SETTINGS

                    TrieSettings ts      = new TrieSettings();
                    IStorage     storage = null;


                    ////Checking if default Flusg Disk behaviour was overriden
                    //ts.DiskFlushBehaviour = Engine.Configuration.DiskFlushBehaviour;
                    ////Checking if we have alternative DiskFlush behaviour
                    //foreach (var pattern in Engine.Configuration.AlternativeDiskFlushBehaviour)
                    //{
                    //    //pattern.Key
                    //    if (DbUserTables.PatternsIntersect(pattern.Key, userTableName))
                    //    {

                    //        ts.DiskFlushBehaviour = pattern.Value;
                    //        break;
                    //    }
                    //}

                    string alternativeTableLocation = String.Empty;

                    if (CheckAlternativeTableLocationsIntersections(userTableName, out alternativeTableLocation))
                    {
                        ts.StorageWasOverriden = true;

                        if (alternativeTableLocation == String.Empty)
                        {
                            ts.AlternativeTableStorageType = DBreezeConfiguration.eStorage.MEMORY;

                            storage = new StorageLayer(Path.Combine(Engine.MainFolder, fileName.ToString()), ts, Engine.Configuration);
                        }
                        else
                        {
                            ts.AlternativeTableStorageType   = DBreezeConfiguration.eStorage.DISK;
                            ts.AlternativeTableStorageFolder = alternativeTableLocation;

                            DirectoryInfo diAlt = new DirectoryInfo(alternativeTableLocation);
                            if (!diAlt.Exists)
                            {
                                diAlt.Create();
                            }

                            if (!tableExists)
                            {
                                //Deleting physical files related to the table, if they existed - normally they should not
                                DeleteAllReleatedTableFiles(Path.Combine(ts.AlternativeTableStorageFolder, LastFileNumber.ToString()));
                            }

                            storage = new StorageLayer(Path.Combine(ts.AlternativeTableStorageFolder, fileName.ToString()), ts, Engine.Configuration);
                        }
                    }
                    else
                    {
                        if (!tableExists)
                        {
                            //Deleting physical files related to the table, if they existed - normally they should not
                            DeleteAllReleatedTableFiles(Path.Combine(Engine.MainFolder, LastFileNumber.ToString()));
                        }

                        storage = new StorageLayer(Path.Combine(Engine.MainFolder, fileName.ToString()), ts, Engine.Configuration);
                    }

                    //storage = new StorageLayer(Path.Combine(Engine.MainFolder, fileName.ToString()), ts, Engine.Configuration);

                    LTrie trie = new LTrie(storage);

                    //Setting LTrie user table name
                    trie.TableName = userTableName;

                    //_openTablesHolder.Add(tableName, trie);

                    //Automatically increased usage in OpenTable constructor
                    _openTablesHolder.Add(tableName, new OpenTable(trie));

                    return(trie);
                }
                catch (System.Exception ex)
                {
                    //CASCADE
                    throw ex;
                }
                finally
                {
                    _sync_openTablesHolder.ExitWriteLock();
                }
            }
            catch (Exception ex)
            {
                throw DBreezeException.Throw(DBreezeException.eDBreezeExceptions.SCHEME_GET_TABLE_WRITE_FAILED, tableName, ex);
            }
            finally
            {
                _sync_openTablesHolder.ExitUpgradeableReadLock();
            }
        }
Пример #19
0
 public AlgorithmFlowConnector(AlgorithmFlowElement owner, string name, bool isInput, StorageLayer layer)
     : base(owner, name, isInput)
 {
     this.m_LayerOwner = owner;
 }