How to increase speed of execution time?

I think the best is to put some brain in your code.
I guess ds is the result of a query in database and that NO OF UNITS is not scattered in every columns.
Detecting which columns can hold this string would greatly improve the runtime.

You can safely remove Trim() from your code.

Step 1 - Parallelize the processing

            var bag = new ConcurrentBag<tuple><int,>>();

            Parallel.For(0, ds.Tables[s].Rows.Count, (i) =>
            {
                for (int j = 0; j < ds.Tables[s].Columns.Count; j++)
                {
                    if (ds.Tables[s].Rows[i][j].ToString().ToUpper().Trim().Contains("NO OF UNITS"))
                    {

                        int t = j + 1;
                        if (ds.Tables[s].Rows[i][t].ToString() == "")
                        {
                            bag.Add(new Tuple<int,>(i, j));
                        }
                    }
                }
            });
</tuple>

Step 2 - Perform a bulk operation

var indexes = bag.ToList();

// Do a bulk operation

How you do the bulk operation depends significantly on what DB server you're using and how you want to hook into the data locally. Inserting is really expensive one at a time... If your DataTable is purely disconnected you can just sequentially add them.

Step 3 - Design the database better

I put this as the last step because, realistically, changing schemas in a deployed or legacy application can be challenging and risky. The first two steps are also easier to implement and you want to do those anyway... Searching values for hard coded values in databases that are meaningful is really bad. You want to have metadata that can be enforced with referential integrity so the results this process can come from an optimized query.

Ok - I'll give you the very quick version.

You should already have linq available if your using any sort of recent version of visual studio. You may not even have to add the using reference.

Linq is a query syntax used by .net to simplify loops like the one you show above.

I use linq extension syntax, so that's what I'll show you here. Others prefer the query syntax so you could always get help translating from one to the other.


No this query it pretty complex, so bare with me

ds.Tables[s].Rows 
    .Cast<datarow>() 
    
var columns = ds.Tables[s].Columns.Cast<datacolumn>().Count();
ds.Tables[s].Rows//these are not currently queriable so we have to cast them out
   .Cast<datarow>() //this is only needed with collections 
   .Where(   //we want to bring back only rows that match the conditions
      dr =>  //this represents a single row
             //The rest of this is lambda.  thing of 'dr' as a parameter and the rest as a function (not entirely true) 
      {
         int i = //get the index of the "NO OF UNITS" item
           dr.ItemArray  //the columns in the row
           .Select((item, index) => new {item, index})  //we need the index so select an anon object
           .Where(  //select only the cell we want
               n => // n represents a class{item = object, index = int} that we just created
               n.item.ToString().ToUpper().Contains("NO OF UNITS") && //check the value
               (n.index + 1) < columns)  //check it's not the last column
               .Select(n => n.index + 1)  //select the next index
               .FirstOrDefault(); will return zero if conditions are not met 
           return i != 0 && string.IsNullOrEmpty(dr.ItemArray[i].ToString());
           // return false if index is zero or next item in not empty.
           //We must return a boolean to the "Where" clause.
     })
   //Now we have our rows.  You can do what you like.  Select any detail you want from the row or just create new rows in dt
   .Select(r=>);

</datarow></datacolumn></datarow>

This is pretty advanced linq & lambda.
I know you'll have loads of questions about this. ^_^

You should update the database so that it uses predefined columns of appropriate type. Don't expect to get good performance from a poorly designed database.

Thus, the best solution would be to convert the database once and then use it in the new format both for queries and adding new stuff.

If the database is remote and only a few rows need to be returned, then doing filtering mainly on server would help a lot.

If you really have to process a lot of unstructured data, it would probably be best to use a SQL reader for that kind of code.

If you need performance, then learn to properly design a database and write efficient queries.