simplestl stack

nihui · nihui · commit 743f5944ea07 · 2025-03-04T19:07:11.000+08:00
diff --git a/src/expression.cpp b/src/expression.cpp
@@ -148,7 +148,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
     };
 
     // scan and stack
-    std::vector<typed_value> exprstack;
+    std::stack<typed_value> exprstack;
     for (int i = (int)tokens.size() - 1; i >= 0; i--)
     {
         const std::string& t = tokens[i];
@@ -179,21 +179,14 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
 
             // NCNN_LOGE("t = %s  =>  %d", t.c_str(), size);
 
-            exprstack.push_back(size);
+            exprstack.push(size);
         }
         else if (t == "+" || t == "-" || t == "*" || t == "//" || t == "max" || t == "min")
         {
-#if NCNN_SIMPLESTL
-            typed_value ta = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-            typed_value tb = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-#else
-            typed_value ta = exprstack.back();
-            exprstack.pop_back();
-            typed_value tb = exprstack.back();
-            exprstack.pop_back();
-#endif
+            typed_value ta = exprstack.top();
+            exprstack.pop();
+            typed_value tb = exprstack.top();
+            exprstack.pop();
 
             if (ta.type == 0 && tb.type == 0)
             {
@@ -233,7 +226,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
                 {
                     r = std::min(a, b);
                 }
-                exprstack.push_back(r);
+                exprstack.push(r);
             }
             else
             {
@@ -265,18 +258,13 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
                 {
                     r = std::min(a, b);
                 }
-                exprstack.push_back(r);
+                exprstack.push(r);
             }
         }
         else if (t == "abs" || t == "neg" || t == "sign" || t == "square")
         {
-#if NCNN_SIMPLESTL
-            typed_value ta = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-#else
-            typed_value ta = exprstack.back();
-            exprstack.pop_back();
-#endif
+            typed_value ta = exprstack.top();
+            exprstack.pop();
 
             if (ta.type == 0)
             {
@@ -299,7 +287,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
                 {
                     r = a * a;
                 }
-                exprstack.push_back(r);
+                exprstack.push(r);
             }
             else
             {
@@ -322,23 +310,18 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
                 {
                     r = a * a;
                 }
-                exprstack.push_back(r);
+                exprstack.push(r);
             }
         }
         else if (t == "trunc" || t == "ceil" || t == "floor" || t == "round")
         {
-#if NCNN_SIMPLESTL
-            typed_value ta = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-#else
-            typed_value ta = exprstack.back();
-            exprstack.pop_back();
-#endif
+            typed_value ta = exprstack.top();
+            exprstack.pop();
 
             if (ta.type == 0)
             {
                 const int a = ta.i;
-                exprstack.push_back(a);
+                exprstack.push(a);
             }
             else
             {
@@ -361,7 +344,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
                 {
                     r = (int)round(a);
                 }
-                exprstack.push_back(r);
+                exprstack.push(r);
             }
         }
         else if (t == "acos"
@@ -384,13 +367,8 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
                  || t == "tan"
                  || t == "tanh")
         {
-#if NCNN_SIMPLESTL
-            typed_value ta = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-#else
-            typed_value ta = exprstack.back();
-            exprstack.pop_back();
-#endif
+            typed_value ta = exprstack.top();
+            exprstack.pop();
 
             const float a = ta.type == 0 ? ta.i : ta.f;
 
@@ -471,7 +449,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
             {
                 r = tanhf(a);
             }
-            exprstack.push_back(r);
+            exprstack.push(r);
         }
         else if (t == "/"
                  || t == "atan2"
@@ -480,17 +458,10 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
                  || t == "remainder"
                  || t == "logaddexp")
         {
-#if NCNN_SIMPLESTL
-            typed_value ta = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-            typed_value tb = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-#else
-            typed_value ta = exprstack.back();
-            exprstack.pop_back();
-            typed_value tb = exprstack.back();
-            exprstack.pop_back();
-#endif
+            typed_value ta = exprstack.top();
+            exprstack.pop();
+            typed_value tb = exprstack.top();
+            exprstack.pop();
 
             const float a = ta.type == 0 ? ta.i : ta.f;
             const float b = tb.type == 0 ? tb.i : tb.f;
@@ -522,21 +493,14 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
             {
                 r = logf(expf(a) + expf(b));
             }
-            exprstack.push_back(r);
+            exprstack.push(r);
         }
         else if (t == "and" || t == "or" || t == "xor" || t == "lshift" || t == "rshift")
         {
-#if NCNN_SIMPLESTL
-            typed_value ta = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-            typed_value tb = exprstack[exprstack.size() - 1];
-            exprstack.resize(exprstack.size() - 1);
-#else
-            typed_value ta = exprstack.back();
-            exprstack.pop_back();
-            typed_value tb = exprstack.back();
-            exprstack.pop_back();
-#endif
+            typed_value ta = exprstack.top();
+            exprstack.pop();
+            typed_value tb = exprstack.top();
+            exprstack.pop();
 
             // assert ta.type == 0 && tb.type == 0
 
@@ -564,7 +528,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
             {
                 r = a >> b;
             }
-            exprstack.push_back(r);
+            exprstack.push(r);
         }
         else
         {
@@ -575,38 +539,28 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector
             int nscanf = sscanf(t.c_str(), "%f", &vf);
             if (nscani == 1 && nscanf == 1 && vi == vf)
             {
-                exprstack.push_back(vi);
+                exprstack.push(vi);
             }
             else if (nscanf == 1)
             {
-                exprstack.push_back(vf);
+                exprstack.push(vf);
             }
             else
             {
                 NCNN_LOGE("malformed literal token %s", t.c_str());
-                exprstack.push_back(0);
+                exprstack.push(0);
             }
         }
     }
 
     std::vector<int> list;
-#if NCNN_SIMPLESTL
-    int size = exprstack[exprstack.size() - 1].to_int();
-    exprstack.resize(exprstack.size() - 1);
-#else
-    int size = exprstack.back().to_int();
-    exprstack.pop_back();
-#endif
+    int size = exprstack.top().to_int();
+    exprstack.pop();
     list.push_back(size);
     while (!exprstack.empty())
     {
-#if NCNN_SIMPLESTL
-        size = exprstack[exprstack.size() - 1].to_int();
-        exprstack.resize(exprstack.size() - 1);
-#else
-        size = exprstack.back().to_int();
-        exprstack.pop_back();
-#endif
+        size = exprstack.top().to_int();
+        exprstack.pop();
         list.push_back(size);
     }
 
diff --git a/src/platform.h.in b/src/platform.h.in
@@ -272,6 +272,7 @@ static inline void swap_endianness_32(void* x)
 #include <algorithm>
 #include <list>
 #include <vector>
+#include <stack>
 #include <string>
 #endif
 
diff --git a/src/simplestl.h b/src/simplestl.h
@@ -498,6 +498,20 @@ struct vector
         return pos;
     }
 
+    void pop_back()
+    {
+        if (size_ > 0)
+        {
+            data_[size_ - 1].~T();
+            size_--;
+        }
+    }
+
+    T& back() const
+    {
+        return data_[size_ - 1];
+    }
+
 protected:
     T* data_;
     size_t size_;
@@ -519,6 +533,40 @@ struct vector
     }
 };
 
+template<typename T>
+struct stack : protected vector<T>
+{
+    void push(const T& t)
+    {
+        vector<T>::push_back(t);
+    }
+
+    void pop()
+    {
+        vector<T>::pop_back();
+    }
+
+    T& top()
+    {
+        return vector<T>::back();
+    }
+
+    bool empty() const
+    {
+        return vector<T>::empty();
+    }
+
+    size_t size() const
+    {
+        return vector<T>::size();
+    }
+
+    void clear()
+    {
+        vector<T>::clear();
+    }
+};
+
 struct NCNN_EXPORT string : public vector<char>
 {
     string()
diff --git a/tools/pnnx/src/pass_ncnn/convert_reshape_expression.cpp b/tools/pnnx/src/pass_ncnn/convert_reshape_expression.cpp
@@ -303,6 +303,12 @@ void convert_reshape_expression(Graph& graph)
                             }
                             else
                             {
+                                if (input_index > 9)
+                                {
+                                    // ncnn can only handle at most 10 reference blobs
+                                    fprintf(stderr, "expression with large reference id %d is not supported yet\n");
+                                }
+
                                 int bi = std::stoi(b);
 
                                 const int a_batch_index = ordered_references[input_index]->params["__batch_index"].i;

Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`148`	`148`	`};`
`149`	`149`
`150`	`150`	`// scan and stack`
`151`		`- std::vector<typed_value> exprstack;`
	`151`	`+ std::stack<typed_value> exprstack;`
`152`	`152`	`for (int i = (int)tokens.size() - 1; i >= 0; i--)`
`153`	`153`	`{`
`154`	`154`	`const std::string& t = tokens[i];`
`@@ -179,21 +179,14 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`179`	`179`
`180`	`180`	`// NCNN_LOGE("t = %s => %d", t.c_str(), size);`
`181`	`181`
`182`		`- exprstack.push_back(size);`
	`182`	`+ exprstack.push(size);`
`183`	`183`	`}`
`184`	`184`	`else if (t == "+" \|\| t == "-" \|\| t == "*" \|\| t == "//" \|\| t == "max" \|\| t == "min")`
`185`	`185`	`{`
`186`		`-#if NCNN_SIMPLESTL`
`187`		`- typed_value ta = exprstack[exprstack.size() - 1];`
`188`		`- exprstack.resize(exprstack.size() - 1);`
`189`		`- typed_value tb = exprstack[exprstack.size() - 1];`
`190`		`- exprstack.resize(exprstack.size() - 1);`
`191`		`-#else`
`192`		`- typed_value ta = exprstack.back();`
`193`		`- exprstack.pop_back();`
`194`		`- typed_value tb = exprstack.back();`
`195`		`- exprstack.pop_back();`
`196`		`-#endif`
	`186`	`+ typed_value ta = exprstack.top();`
	`187`	`+ exprstack.pop();`
	`188`	`+ typed_value tb = exprstack.top();`
	`189`	`+ exprstack.pop();`
`197`	`190`
`198`	`191`	`if (ta.type == 0 && tb.type == 0)`
`199`	`192`	`{`
`@@ -233,7 +226,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`233`	`226`	`{`
`234`	`227`	`r = std::min(a, b);`
`235`	`228`	`}`
`236`		`- exprstack.push_back(r);`
	`229`	`+ exprstack.push(r);`
`237`	`230`	`}`
`238`	`231`	`else`
`239`	`232`	`{`
`@@ -265,18 +258,13 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`265`	`258`	`{`
`266`	`259`	`r = std::min(a, b);`
`267`	`260`	`}`
`268`		`- exprstack.push_back(r);`
	`261`	`+ exprstack.push(r);`
`269`	`262`	`}`
`270`	`263`	`}`
`271`	`264`	`else if (t == "abs" \|\| t == "neg" \|\| t == "sign" \|\| t == "square")`
`272`	`265`	`{`
`273`		`-#if NCNN_SIMPLESTL`
`274`		`- typed_value ta = exprstack[exprstack.size() - 1];`
`275`		`- exprstack.resize(exprstack.size() - 1);`
`276`		`-#else`
`277`		`- typed_value ta = exprstack.back();`
`278`		`- exprstack.pop_back();`
`279`		`-#endif`
	`266`	`+ typed_value ta = exprstack.top();`
	`267`	`+ exprstack.pop();`
`280`	`268`
`281`	`269`	`if (ta.type == 0)`
`282`	`270`	`{`
`@@ -299,7 +287,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`299`	`287`	`{`
`300`	`288`	`r = a * a;`
`301`	`289`	`}`
`302`		`- exprstack.push_back(r);`
	`290`	`+ exprstack.push(r);`
`303`	`291`	`}`
`304`	`292`	`else`
`305`	`293`	`{`
`@@ -322,23 +310,18 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`322`	`310`	`{`
`323`	`311`	`r = a * a;`
`324`	`312`	`}`
`325`		`- exprstack.push_back(r);`
	`313`	`+ exprstack.push(r);`
`326`	`314`	`}`
`327`	`315`	`}`
`328`	`316`	`else if (t == "trunc" \|\| t == "ceil" \|\| t == "floor" \|\| t == "round")`
`329`	`317`	`{`
`330`		`-#if NCNN_SIMPLESTL`
`331`		`- typed_value ta = exprstack[exprstack.size() - 1];`
`332`		`- exprstack.resize(exprstack.size() - 1);`
`333`		`-#else`
`334`		`- typed_value ta = exprstack.back();`
`335`		`- exprstack.pop_back();`
`336`		`-#endif`
	`318`	`+ typed_value ta = exprstack.top();`
	`319`	`+ exprstack.pop();`
`337`	`320`
`338`	`321`	`if (ta.type == 0)`
`339`	`322`	`{`
`340`	`323`	`const int a = ta.i;`
`341`		`- exprstack.push_back(a);`
	`324`	`+ exprstack.push(a);`
`342`	`325`	`}`
`343`	`326`	`else`
`344`	`327`	`{`
`@@ -361,7 +344,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`361`	`344`	`{`
`362`	`345`	`r = (int)round(a);`
`363`	`346`	`}`
`364`		`- exprstack.push_back(r);`
	`347`	`+ exprstack.push(r);`
`365`	`348`	`}`
`366`	`349`	`}`
`367`	`350`	`else if (t == "acos"`
`@@ -384,13 +367,8 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`384`	`367`	`\|\| t == "tan"`
`385`	`368`	`\|\| t == "tanh")`
`386`	`369`	`{`
`387`		`-#if NCNN_SIMPLESTL`
`388`		`- typed_value ta = exprstack[exprstack.size() - 1];`
`389`		`- exprstack.resize(exprstack.size() - 1);`
`390`		`-#else`
`391`		`- typed_value ta = exprstack.back();`
`392`		`- exprstack.pop_back();`
`393`		`-#endif`
	`370`	`+ typed_value ta = exprstack.top();`
	`371`	`+ exprstack.pop();`
`394`	`372`
`395`	`373`	`const float a = ta.type == 0 ? ta.i : ta.f;`
`396`	`374`
`@@ -471,7 +449,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`471`	`449`	`{`
`472`	`450`	`r = tanhf(a);`
`473`	`451`	`}`
`474`		`- exprstack.push_back(r);`
	`452`	`+ exprstack.push(r);`
`475`	`453`	`}`
`476`	`454`	`else if (t == "/"`
`477`	`455`	`\|\| t == "atan2"`
`@@ -480,17 +458,10 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`480`	`458`	`\|\| t == "remainder"`
`481`	`459`	`\|\| t == "logaddexp")`
`482`	`460`	`{`
`483`		`-#if NCNN_SIMPLESTL`
`484`		`- typed_value ta = exprstack[exprstack.size() - 1];`
`485`		`- exprstack.resize(exprstack.size() - 1);`
`486`		`- typed_value tb = exprstack[exprstack.size() - 1];`
`487`		`- exprstack.resize(exprstack.size() - 1);`
`488`		`-#else`
`489`		`- typed_value ta = exprstack.back();`
`490`		`- exprstack.pop_back();`
`491`		`- typed_value tb = exprstack.back();`
`492`		`- exprstack.pop_back();`
`493`		`-#endif`
	`461`	`+ typed_value ta = exprstack.top();`
	`462`	`+ exprstack.pop();`
	`463`	`+ typed_value tb = exprstack.top();`
	`464`	`+ exprstack.pop();`
`494`	`465`
`495`	`466`	`const float a = ta.type == 0 ? ta.i : ta.f;`
`496`	`467`	`const float b = tb.type == 0 ? tb.i : tb.f;`
`@@ -522,21 +493,14 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`522`	`493`	`{`
`523`	`494`	`r = logf(expf(a) + expf(b));`
`524`	`495`	`}`
`525`		`- exprstack.push_back(r);`
	`496`	`+ exprstack.push(r);`
`526`	`497`	`}`
`527`	`498`	`else if (t == "and" \|\| t == "or" \|\| t == "xor" \|\| t == "lshift" \|\| t == "rshift")`
`528`	`499`	`{`
`529`		`-#if NCNN_SIMPLESTL`
`530`		`- typed_value ta = exprstack[exprstack.size() - 1];`
`531`		`- exprstack.resize(exprstack.size() - 1);`
`532`		`- typed_value tb = exprstack[exprstack.size() - 1];`
`533`		`- exprstack.resize(exprstack.size() - 1);`
`534`		`-#else`
`535`		`- typed_value ta = exprstack.back();`
`536`		`- exprstack.pop_back();`
`537`		`- typed_value tb = exprstack.back();`
`538`		`- exprstack.pop_back();`
`539`		`-#endif`
	`500`	`+ typed_value ta = exprstack.top();`
	`501`	`+ exprstack.pop();`
	`502`	`+ typed_value tb = exprstack.top();`
	`503`	`+ exprstack.pop();`
`540`	`504`
`541`	`505`	`// assert ta.type == 0 && tb.type == 0`
`542`	`506`
`@@ -564,7 +528,7 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`564`	`528`	`{`
`565`	`529`	`r = a >> b;`
`566`	`530`	`}`
`567`		`- exprstack.push_back(r);`
	`531`	`+ exprstack.push(r);`
`568`	`532`	`}`
`569`	`533`	`else`
`570`	`534`	`{`
`@@ -575,38 +539,28 @@ std::vector<int> eval_list_expression(const std::string& expr, const std::vector`
`575`	`539`	`int nscanf = sscanf(t.c_str(), "%f", &vf);`
`576`	`540`	`if (nscani == 1 && nscanf == 1 && vi == vf)`
`577`	`541`	`{`
`578`		`- exprstack.push_back(vi);`
	`542`	`+ exprstack.push(vi);`
`579`	`543`	`}`
`580`	`544`	`else if (nscanf == 1)`
`581`	`545`	`{`
`582`		`- exprstack.push_back(vf);`
	`546`	`+ exprstack.push(vf);`
`583`	`547`	`}`
`584`	`548`	`else`
`585`	`549`	`{`
`586`	`550`	`NCNN_LOGE("malformed literal token %s", t.c_str());`
`587`		`- exprstack.push_back(0);`
	`551`	`+ exprstack.push(0);`
`588`	`552`	`}`
`589`	`553`	`}`
`590`	`554`	`}`
`591`	`555`
`592`	`556`	`std::vector<int> list;`
`593`		`-#if NCNN_SIMPLESTL`
`594`		`- int size = exprstack[exprstack.size() - 1].to_int();`
`595`		`- exprstack.resize(exprstack.size() - 1);`
`596`		`-#else`
`597`		`- int size = exprstack.back().to_int();`
`598`		`- exprstack.pop_back();`
`599`		`-#endif`
	`557`	`+ int size = exprstack.top().to_int();`
	`558`	`+ exprstack.pop();`
`600`	`559`	`list.push_back(size);`
`601`	`560`	`while (!exprstack.empty())`
`602`	`561`	`{`
`603`		`-#if NCNN_SIMPLESTL`
`604`		`- size = exprstack[exprstack.size() - 1].to_int();`
`605`		`- exprstack.resize(exprstack.size() - 1);`
`606`		`-#else`
`607`		`- size = exprstack.back().to_int();`
`608`		`- exprstack.pop_back();`
`609`		`-#endif`
	`562`	`+ size = exprstack.top().to_int();`
	`563`	`+ exprstack.pop();`
`610`	`564`	`list.push_back(size);`
`611`	`565`	`}`
`612`	`566`
Original file line number	Diff line number	Diff line change
`@@ -303,6 +303,12 @@ void convert_reshape_expression(Graph& graph)`
`303`	`303`	`}`
`304`	`304`	`else`
`305`	`305`	`{`
	`306`	`+ if (input_index > 9)`
	`307`	`+ {`
	`308`	`+ // ncnn can only handle at most 10 reference blobs`
	`309`	`+ fprintf(stderr, "expression with large reference id %d is not supported yet\n");`
	`310`	`+ }`
	`311`	`+`
`306`	`312`	`int bi = std::stoi(b);`
`307`	`313`
`308`	`314`	`const int a_batch_index = ordered_references[input_index]->params["__batch_index"].i;`